From e19600a9f954624c7100e846bc1a381fd9835d86 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 12 Feb 2022 18:02:37 +0800 Subject: [PATCH 01/81] Download, build and install bullet's library files Required for generating and building JNI bindings. --- bullet/cppbuild.sh | 52 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) create mode 100755 bullet/cppbuild.sh diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh new file mode 100755 index 00000000000..960f14cf494 --- /dev/null +++ b/bullet/cppbuild.sh @@ -0,0 +1,52 @@ +#!/bin/bash + +# This file is meant to be included by the parent cppbuild.sh script +if [[ -z "$PLATFORM" ]]; then + pushd .. + bash cppbuild.sh "$@" opencl + popd + exit +fi + +BULLET_VERSION=3.21 +download https://github.com/bulletphysics/bullet3/archive/refs/tags/$BULLET_VERSION.zip bullet-$BULLET_VERSION.zip + +mkdir -p $PLATFORM +cd $PLATFORM +INSTALL_PATH=`pwd` + +echo "Decompressing archives..." +unzip -q ../bullet-$BULLET_VERSION.zip + +case $PLATFORM in + linux-x86_64) + cd bullet3-$BULLET_VERSION + mkdir .build + cd .build + cmake \ + -DBUILD_BULLET2_DEMOS=OFF \ + -DBUILD_CLSOCKET=OFF \ + -DBUILD_CPU_DEMOS=OFF \ + -DBUILD_EGL=OFF \ + -DBUILD_ENET=OFF \ + -DBUILD_EXTRAS=OFF \ + -DBUILD_OPENGL3_DEMOS=OFF \ + -DBUILD_SHARED_LIBS=ON \ + -DBUILD_UNIT_TESTS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH \ + -DENABLE_VHACD=OFF \ + -DUSE_DOUBLE_PRECISION=OFF \ + -DUSE_GLUT=OFF \ + -DUSE_GRAPHICAL_BENCHMARK=OFF \ + .. + make -j $MAKEJ + make install/strip + cd ../.. + ;; + *) + echo "Error: Platform \"$PLATFORM\" is not supported" + ;; +esac + +cd .. From 356a22d47c7707e228262c43dc7c4b9de39eb7a0 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Feb 2022 17:45:12 +0800 Subject: [PATCH 02/81] POM scripts necessary for building the bullet preset --- bullet/platform/pom.xml | 110 +++++++++++++++++++++++++ bullet/pom.xml | 55 +++++++++++++ bullet/src/main/java9/module-info.java | 4 + platform/pom.xml | 6 ++ pom.xml | 2 + 5 files changed, 177 insertions(+) create mode 100644 bullet/platform/pom.xml create mode 100644 bullet/pom.xml create mode 100644 bullet/src/main/java9/module-info.java diff --git a/bullet/platform/pom.xml b/bullet/platform/pom.xml new file mode 100644 index 00000000000..071bc3bc328 --- /dev/null +++ b/bullet/platform/pom.xml @@ -0,0 +1,110 @@ + + + 4.0.0 + + + org.bytedeco + javacpp-presets + 1.5.7 + ../../ + + + org.bytedeco + bullet-platform + 3.21-${project.parent.version} + JavaCPP Presets Platform for Bullet Physics SDK + + + bullet + + + + + org.bytedeco + javacpp-platform + ${project.parent.version} + + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.linux-x86_64} + + + + + + + maven-jar-plugin + + + default-jar + + + + + ${javacpp.moduleId}.jar + ${javacpp.moduleId}-linux-x86_64.jar + + + + + + + empty-javadoc-jar + + jar + + + javadoc + + + + empty-sources-jar + + jar + + + sources + + + + + + org.moditect + moditect-maven-plugin + + + add-module-infos + none + + + add-platform-module-info + package + + add-module-info + + + + + ${project.build.directory}/${project.artifactId}.jar + + module org.bytedeco.${javacpp.moduleId}.platform { + requires static org.bytedeco.${javacpp.moduleId}.linux.x86_64; + } + + + + + + + + + + diff --git a/bullet/pom.xml b/bullet/pom.xml new file mode 100644 index 00000000000..d04dd70431b --- /dev/null +++ b/bullet/pom.xml @@ -0,0 +1,55 @@ + + + 4.0.0 + + + org.bytedeco + javacpp-presets + 1.5.7 + + + org.bytedeco + bullet + 3.21-${project.parent.version} + JavaCPP Presets for Bullet Physics SDK + + + + org.bytedeco + javacpp + + + + + + + maven-resources-plugin + + + maven-compiler-plugin + + + org.bytedeco + javacpp + + + maven-jar-plugin + + + org.moditect + moditect-maven-plugin + + + maven-dependency-plugin + + + maven-source-plugin + + + maven-javadoc-plugin + + + + + diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java new file mode 100644 index 00000000000..500b5ef4c80 --- /dev/null +++ b/bullet/src/main/java9/module-info.java @@ -0,0 +1,4 @@ +module org.bytedeco.bullet { + requires transitive org.bytedeco.javacpp; + exports org.bytedeco.bullet.presets; +} diff --git a/platform/pom.xml b/platform/pom.xml index 54b4de76b0d..f7d4b0f463b 100644 --- a/platform/pom.xml +++ b/platform/pom.xml @@ -72,6 +72,7 @@ ../cpu_features/platform ../modsecurity/platform ../systems/platform + ../bullet/platform @@ -366,6 +367,11 @@ systems-platform ${project.version} + + org.bytedeco + bullet-platform + 3.21-${project.version} + diff --git a/pom.xml b/pom.xml index 27d703f4976..7be8eccacbe 100644 --- a/pom.xml +++ b/pom.xml @@ -634,6 +634,7 @@ cpu_features modsecurity systems + bullet ${os.name}-${os.arch} @@ -1403,6 +1404,7 @@ cpu_features modsecurity systems + bullet From f3fae53ce2f8f5db0d9c2fc35ef47add71cf278c Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Feb 2022 17:47:11 +0800 Subject: [PATCH 03/81] Fix bullet's cppbuild Allow recurring building of the package. --- bullet/cppbuild.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh index 960f14cf494..8b819a1e765 100755 --- a/bullet/cppbuild.sh +++ b/bullet/cppbuild.sh @@ -16,12 +16,12 @@ cd $PLATFORM INSTALL_PATH=`pwd` echo "Decompressing archives..." -unzip -q ../bullet-$BULLET_VERSION.zip +unzip -qo ../bullet-$BULLET_VERSION.zip case $PLATFORM in linux-x86_64) cd bullet3-$BULLET_VERSION - mkdir .build + [ -d .build ] || mkdir .build cd .build cmake \ -DBUILD_BULLET2_DEMOS=OFF \ From 1c3a5df6e1d64592f3cc18dac6e2aed4175443ac Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Feb 2022 17:53:01 +0800 Subject: [PATCH 04/81] Generate bindings for bullet's LinearMath library Part of the bullet's package. --- bullet/pom.xml | 5 + .../java/org/bytedeco/bullet/LinearMath.java | 2675 +++++++++++++++++ .../bytedeco/bullet/presets/LinearMath.java | 89 + bullet/src/main/java9/module-info.java | 1 + 4 files changed, 2770 insertions(+) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath.java create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java diff --git a/bullet/pom.xml b/bullet/pom.xml index d04dd70431b..41dff83ca23 100644 --- a/bullet/pom.xml +++ b/bullet/pom.xml @@ -32,6 +32,11 @@ org.bytedeco javacpp + + + ${basedir}/cppbuild/${javacpp.platform}/include/bullet + + maven-jar-plugin diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath.java new file mode 100644 index 00000000000..a7d137164c6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath.java @@ -0,0 +1,2675 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +public class LinearMath extends org.bytedeco.bullet.presets.LinearMath { + static { Loader.load(); } + +// Parsed from LinearMath/btScalar.h + +/* +Copyright (c) 2003-2009 Erwin Coumans http://bullet.googlecode.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SCALAR_H +// #define BT_SCALAR_H + +// #ifdef BT_MANAGED_CODE +//Aligned data types not supported in managed code +// #pragma unmanaged +// #endif + +// #include +// #include //size_t for MSVC 6.0 +// #include + +/* SVN $Revision$ on $Date$ from http://bullet.googlecode.com*/ +public static final int BT_BULLET_VERSION = 320; + +public static native int btGetVersion(); + +public static native int btIsDoublePrecision(); + + +// The following macro "BT_NOT_EMPTY_FILE" can be put into a file +// in order suppress the MS Visual C++ Linker warning 4221 +// +// warning LNK4221: no public symbols found; archive member will be inaccessible +// +// This warning occurs on PC and XBOX when a file compiles out completely +// has no externally visible symbols which may be dependant on configuration +// #defines and options. +// +// see more https://stackoverflow.com/questions/1822887/what-is-the-best-way-to-eliminate-ms-visual-c-linker-warning-warning-lnk422 + +// #if defined(_MSC_VER) +// #else +// #define BT_NOT_EMPTY_FILE +// #endif + +// clang and most formatting tools don't support indentation of preprocessor guards, so turn it off +// clang-format off +// #if defined(DEBUG) || defined (_DEBUG) +// #endif + +// #ifdef _WIN32 + +// #else//_WIN32 + +// #if defined (__CELLOS_LV2__) + +// #else//defined (__CELLOS_LV2__) + +// #ifdef USE_LIBSPE2 + + +// #else//USE_LIBSPE2 + //non-windows systems + +// #if (defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION))) + +// #else//__APPLE__ + +// #define SIMD_FORCE_INLINE inline + /**\todo: check out alignment methods for other platforms/compilers + * #define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16))) + * #define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64))) + * #define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128))) */ +// #define ATTRIBUTE_ALIGNED16(a) a +// #define ATTRIBUTE_ALIGNED64(a) a +// #define ATTRIBUTE_ALIGNED128(a) a +// #ifndef assert +// #include +// #endif + +// #if defined(DEBUG) || defined (_DEBUG) +// #else +// #define btAssert(x) +// #endif + + //btFullAssert is optional, slows down a lot +// #define btFullAssert(x) +// #define btLikely(_c) _c +// #define btUnlikely(_c) _c +// #endif //__APPLE__ +// #endif // LIBSPE2 +// #endif //__CELLOS_LV2__ +// #endif//_WIN32 + + +/**The btScalar type abstracts floating point numbers, to easily switch between double and single floating point precision. */ +// #if defined(BT_USE_DOUBLE_PRECISION) +// #else + //keep BT_LARGE_FLOAT*BT_LARGE_FLOAT < FLT_MAX + public static final double BT_LARGE_FLOAT = 1e18f; +// #endif + +// #ifdef BT_USE_SSE +// #endif //BT_USE_SSE + +// #if defined(BT_USE_SSE) +// #else//BT_USE_SSE + +// #ifdef BT_USE_NEON +// #else //BT_USE_NEON + +// #ifndef BT_INFINITY + public static class btInfMaskConverter extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btInfMaskConverter(Pointer p) { super(p); } + + public native float mask(); public native btInfMaskConverter mask(float setter); + public native int intmask(); public native btInfMaskConverter intmask(int setter); + public btInfMaskConverter(int _mask/*=0x7F800000*/) { super((Pointer)null); allocate(_mask); } + private native void allocate(int _mask/*=0x7F800000*/); + public btInfMaskConverter() { super((Pointer)null); allocate(); } + private native void allocate(); + } + public static native @ByRef btInfMaskConverter btInfinityMask(); public static native void btInfinityMask(btInfMaskConverter setter); +// #define BT_INFINITY (btInfinityMask.mask) + public static native int btGetInfinityMask(); +// #endif +// #endif //BT_USE_NEON + +// #endif //BT_USE_SSE + +// #ifdef BT_USE_NEON +// #endif//BT_USE_NEON + +// #define BT_DECLARE_ALIGNED_ALLOCATOR() +// SIMD_FORCE_INLINE void *operator new(size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } +// SIMD_FORCE_INLINE void operator delete(void *ptr) { btAlignedFree(ptr); } +// SIMD_FORCE_INLINE void *operator new(size_t, void *ptr) { return ptr; } +// SIMD_FORCE_INLINE void operator delete(void *, void *) {} +// SIMD_FORCE_INLINE void *operator new[](size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } +// SIMD_FORCE_INLINE void operator delete[](void *ptr) { btAlignedFree(ptr); } +// SIMD_FORCE_INLINE void *operator new[](size_t, void *ptr) { return ptr; } +// SIMD_FORCE_INLINE void operator delete[](void *, void *) {} + +// #if defined(BT_USE_DOUBLE_PRECISION) || defined(BT_FORCE_DOUBLE_FUNCTIONS) + + public static native @Cast("btScalar") float btSqrt(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btFabs(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btCos(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btSin(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btTan(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btAcos(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btAsin(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btAtan(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btAtan2(@Cast("btScalar") float x, @Cast("btScalar") float y); + public static native @Cast("btScalar") float btExp(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btLog(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btPow(@Cast("btScalar") float x, @Cast("btScalar") float y); + public static native @Cast("btScalar") float btFmod(@Cast("btScalar") float x, @Cast("btScalar") float y); + +// #else//BT_USE_DOUBLE_PRECISION + +// #endif//BT_USE_DOUBLE_PRECISION + +public static native @MemberGetter double SIMD_PI(); +public static final double SIMD_PI = SIMD_PI(); +public static native @MemberGetter double SIMD_2_PI(); +public static final double SIMD_2_PI = SIMD_2_PI(); +public static native @MemberGetter double SIMD_HALF_PI(); +public static final double SIMD_HALF_PI = SIMD_HALF_PI(); +public static native @MemberGetter double SIMD_RADS_PER_DEG(); +public static final double SIMD_RADS_PER_DEG = SIMD_RADS_PER_DEG(); +public static native @MemberGetter double SIMD_DEGS_PER_RAD(); +public static final double SIMD_DEGS_PER_RAD = SIMD_DEGS_PER_RAD(); +public static native @MemberGetter double SIMDSQRT12(); +public static final double SIMDSQRT12 = SIMDSQRT12(); +// #define btRecipSqrt(x) ((btScalar)(btScalar(1.0) / btSqrt(btScalar(x)))) /* reciprocal square root */ +// #define btRecip(x) (btScalar(1.0) / btScalar(x)) + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define SIMD_EPSILON FLT_EPSILON +// #define SIMD_INFINITY FLT_MAX + public static final double BT_ONE = 1.0f; + public static final double BT_ZERO = 0.0f; + public static final double BT_TWO = 2.0f; + public static final double BT_HALF = 0.5f; +// #endif + +// clang-format on + +public static native @Cast("btScalar") float btAtan2Fast(@Cast("btScalar") float y, @Cast("btScalar") float x); + +public static native @Cast("bool") boolean btFuzzyZero(@Cast("btScalar") float x); + +public static native @Cast("bool") boolean btEqual(@Cast("btScalar") float a, @Cast("btScalar") float eps); +public static native @Cast("bool") boolean btGreaterEqual(@Cast("btScalar") float a, @Cast("btScalar") float eps); + +public static native int btIsNegative(@Cast("btScalar") float x); + +public static native @Cast("btScalar") float btRadians(@Cast("btScalar") float x); +public static native @Cast("btScalar") float btDegrees(@Cast("btScalar") float x); + +// #define BT_DECLARE_HANDLE(name) +// typedef struct name##__ +// { +// int unused; +// } * name + +// #ifndef btFsel +public static native @Cast("btScalar") float btFsel(@Cast("btScalar") float a, @Cast("btScalar") float b, @Cast("btScalar") float c); +// #endif +// #define btFsels(a, b, c) (btScalar) btFsel(a, b, c) + +public static native @Cast("bool") boolean btMachineIsLittleEndian(); + +/**btSelect avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360 + * Thanks Phil Knight. See also http://www.cellperformance.com/articles/2006/04/more_techniques_for_eliminatin_1.html */ +public static native @Cast("unsigned") int btSelect(@Cast("unsigned") int condition, @Cast("unsigned") int valueIfConditionNonZero, @Cast("unsigned") int valueIfConditionZero); +public static native float btSelect(@Cast("unsigned") int condition, float valueIfConditionNonZero, float valueIfConditionZero); + +//PCK: endian swapping functions +public static native @Cast("unsigned") int btSwapEndian(@Cast("unsigned") int val); + +public static native @Cast("unsigned short") short btSwapEndian(@Cast("unsigned short") short val); + +/**btSwapFloat uses using char pointers to swap the endianness +////btSwapFloat/btSwapDouble will NOT return a float, because the machine might 'correct' invalid floating point values + * Not all values of sign/exponent/mantissa are valid floating point numbers according to IEEE 754. + * When a floating point unit is faced with an invalid value, it may actually change the value, or worse, throw an exception. + * In most systems, running user mode code, you wouldn't get an exception, but instead the hardware/os/runtime will 'fix' the number for you. + * so instead of returning a float/double, we return integer/long long integer */ +public static native @Cast("unsigned int") int btSwapEndianFloat(float d); + +// unswap using char pointers +public static native float btUnswapEndianFloat(@Cast("unsigned int") int a); + +// swap using char pointers +public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") BytePointer dst); +public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") ByteBuffer dst); +public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") byte[] dst); + +// unswap using char pointers +public static native double btUnswapEndianDouble(@Cast("const unsigned char*") BytePointer src); +public static native double btUnswapEndianDouble(@Cast("const unsigned char*") ByteBuffer src); +public static native double btUnswapEndianDouble(@Cast("const unsigned char*") byte[] src); + +public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") FloatPointer a, @Cast("const btScalar*") FloatPointer b, int n); +public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") FloatBuffer a, @Cast("const btScalar*") FloatBuffer b, int n); +public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") float[] a, @Cast("const btScalar*") float[] b, int n); + +// returns normalized value in range [-SIMD_PI, SIMD_PI] +public static native @Cast("btScalar") float btNormalizeAngle(@Cast("btScalar") float angleInRadians); + +/**rudimentary class to provide type info */ +@NoOffset public static class btTypedObject extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTypedObject(Pointer p) { super(p); } + + public btTypedObject(int objectType) { super((Pointer)null); allocate(objectType); } + private native void allocate(int objectType); + public native int m_objectType(); public native btTypedObject m_objectType(int setter); + public native int getObjectType(); +} + +/**align a pointer to the provided alignment, upwards */ + +// #endif //BT_SCALAR_H + + +// Parsed from LinearMath/btVector3.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_VECTOR3_H +// #define BT_VECTOR3_H + +//#include +// #include "btScalar.h" +// #include "btMinMax.h" +// #include "btAlignedAllocator.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btVector3Data btVector3FloatData +public static final String btVector3DataName = "btVector3FloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +// #if defined BT_USE_SSE + +// #endif + +// #ifdef BT_USE_NEON + +// #endif + +/**\brief btVector3 can be used to represent 3D points and vectors. + * It has an un-used w component to suit 16-byte alignment when btVector3 is stored in containers. This extra component can be used by derived classes (Quaternion?) or by user + * Ideally, this class should be replaced by a platform optimized SIMD version that keeps the data in registers + */ +@NoOffset public static class btVector3 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVector3(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVector3(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVector3 position(long position) { + return (btVector3)super.position(position); + } + @Override public btVector3 getPointer(long i) { + return new btVector3((Pointer)this).offsetAddress(i); + } + + +// #if defined(__SPU__) && defined(__CELLOS_LV2__) +// #else //__CELLOS_LV2__ __SPU__ +// #if defined(BT_USE_SSE) || defined(BT_USE_NEON) // _WIN32 || ARM +// #else + public native @Cast("btScalar") float m_floats(int i); public native btVector3 m_floats(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_floats(); + /**\brief No initialization constructor */ + public btVector3() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**\brief Constructor from scalars + * @param x X value + * @param y Y value + * @param z Z value + */ + public btVector3(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z) { super((Pointer)null); allocate(_x, _y, _z); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) +// #endif // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON) + + /**\brief Add a vector to this one + * @param The vector to add to this one */ + public native @ByRef @Name("operator +=") btVector3 addPut(@Const @ByRef btVector3 v); + + /**\brief Subtract a vector from this one + * @param The vector to subtract */ + public native @ByRef @Name("operator -=") btVector3 subtractPut(@Const @ByRef btVector3 v); + + /**\brief Scale the vector + * @param s Scale factor */ + public native @ByRef @Name("operator *=") btVector3 multiplyPut(@Cast("const btScalar") float s); + + /**\brief Inversely scale the vector + * @param s Scale factor to divide by */ + public native @ByRef @Name("operator /=") btVector3 dividePut(@Cast("const btScalar") float s); + + /**\brief Return the dot product + * @param v The other vector in the dot product */ + public native @Cast("btScalar") float dot(@Const @ByRef btVector3 v); + + /**\brief Return the length of the vector squared */ + public native @Cast("btScalar") float length2(); + + /**\brief Return the length of the vector */ + public native @Cast("btScalar") float length(); + + /**\brief Return the norm (length) of the vector */ + public native @Cast("btScalar") float norm(); + + /**\brief Return the norm (length) of the vector */ + public native @Cast("btScalar") float safeNorm(); + + /**\brief Return the distance squared between the ends of this and another vector + * This is symantically treating the vector like a point */ + public native @Cast("btScalar") float distance2(@Const @ByRef btVector3 v); + + /**\brief Return the distance between the ends of this and another vector + * This is symantically treating the vector like a point */ + public native @Cast("btScalar") float distance(@Const @ByRef btVector3 v); + + public native @ByRef btVector3 safeNormalize(); + + /**\brief Normalize this vector + * x^2 + y^2 + z^2 = 1 */ + public native @ByRef btVector3 normalize(); + + /**\brief Return a normalized version of this vector */ + public native @ByVal btVector3 normalized(); + + /**\brief Return a rotated version of this vector + * @param wAxis The axis to rotate about + * @param angle The angle to rotate by */ + public native @ByVal btVector3 rotate(@Const @ByRef btVector3 wAxis, @Cast("const btScalar") float angle); + + /**\brief Return the angle between this and another vector + * @param v The other vector */ + public native @Cast("btScalar") float angle(@Const @ByRef btVector3 v); + + /**\brief Return a vector with the absolute values of each element */ + public native @ByVal btVector3 absolute(); + + /**\brief Return the cross product between this and another vector + * @param v The other vector */ + public native @ByVal btVector3 cross(@Const @ByRef btVector3 v); + + public native @Cast("btScalar") float triple(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + + /**\brief Return the axis with the smallest value + * Note return values are 0,1,2 for x, y, or z */ + public native int minAxis(); + + /**\brief Return the axis with the largest value + * Note return values are 0,1,2 for x, y, or z */ + public native int maxAxis(); + + public native int furthestAxis(); + + public native int closestAxis(); + + public native void setInterpolate3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Cast("btScalar") float rt); + + /**\brief Return the linear interpolation between this and another vector + * @param v The other vector + * @param t The ration of this to v (t = 0 => return this, t=1 => return other) */ + public native @ByVal btVector3 lerp(@Const @ByRef btVector3 v, @Cast("const btScalar") float t); + + /**\brief Elementwise multiply this vector by the other + * @param v The other vector */ + public native @ByRef @Name("operator *=") btVector3 multiplyPut(@Const @ByRef btVector3 v); + + /**\brief Return the x value */ + public native @Cast("const btScalar") float getX(); + /**\brief Return the y value */ + public native @Cast("const btScalar") float getY(); + /**\brief Return the z value */ + public native @Cast("const btScalar") float getZ(); + /**\brief Set the x value */ + public native void setX(@Cast("btScalar") float _x); + /**\brief Set the y value */ + public native void setY(@Cast("btScalar") float _y); + /**\brief Set the z value */ + public native void setZ(@Cast("btScalar") float _z); + /**\brief Set the w value */ + public native void setW(@Cast("btScalar") float _w); + /**\brief Return the x value */ + public native @Cast("const btScalar") float x(); + /**\brief Return the y value */ + public native @Cast("const btScalar") float y(); + /**\brief Return the z value */ + public native @Cast("const btScalar") float z(); + /**\brief Return the w value */ + public native @Cast("const btScalar") float w(); + + //SIMD_FORCE_INLINE btScalar& operator[](int i) { return (&m_floats[0])[i]; } + //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; } + /**operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. */ + public native @Cast("btScalar*") @Name("operator btScalar*") FloatPointer asFloatPointer(); + + public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btVector3 other); + + public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef btVector3 other); + + /**\brief Set each element to the max of the current values and the values of another btVector3 + * @param other The other btVector3 to compare with + */ + public native void setMax(@Const @ByRef btVector3 other); + + /**\brief Set each element to the min of the current values and the values of another btVector3 + * @param other The other btVector3 to compare with + */ + public native void setMin(@Const @ByRef btVector3 other); + + public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); + + public native void getSkewSymmetricMatrix(btVector3 v0, btVector3 v1, btVector3 v2); + + public native void setZero(); + + public native @Cast("bool") boolean isZero(); + + public native @Cast("bool") boolean fuzzyZero(); + + public native void serialize(@ByRef btVector3FloatData dataOut); + + public native void deSerialize(@Const @ByRef btVector3DoubleData dataIn); + + public native void deSerialize(@Const @ByRef btVector3FloatData dataIn); + + public native void serializeFloat(@ByRef btVector3FloatData dataOut); + + public native void deSerializeFloat(@Const @ByRef btVector3FloatData dataIn); + + public native void serializeDouble(@ByRef btVector3DoubleData dataOut); + + public native void deSerializeDouble(@Const @ByRef btVector3DoubleData dataIn); + + /**\brief returns index of maximum dot product between this and vectors in array[] + * @param array The other vectors + * @param array_count The number of other vectors + * @param dotOut The maximum dot product */ + public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatPointer dotOut); + public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatBuffer dotOut); + public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef float[] dotOut); + + /**\brief returns index of minimum dot product between this and vectors in array[] + * @param array The other vectors + * @param array_count The number of other vectors + * @param dotOut The minimum dot product */ + public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatPointer dotOut); + public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatBuffer dotOut); + public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef float[] dotOut); + + /* create a vector as btVector3( this->dot( btVector3 v0 ), this->dot( btVector3 v1), this->dot( btVector3 v2 )) */ + public native @ByVal btVector3 dot3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); +} + +/**\brief Return the sum of two vectors (Point symantics)*/ +public static native @ByVal @Name("operator +") btVector3 add(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the elementwise product of two vectors */ +public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the difference between two vectors */ +public static native @ByVal @Name("operator -") btVector3 subtract(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the negative of the vector */ +public static native @ByVal @Name("operator -") btVector3 subtract(@Const @ByRef btVector3 v); + +/**\brief Return the vector scaled by s */ +public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v, @Cast("const btScalar") float s); + +/**\brief Return the vector scaled by s */ +public static native @ByVal @Name("operator *") btVector3 multiply(@Cast("const btScalar") float s, @Const @ByRef btVector3 v); + +/**\brief Return the vector inversely scaled by s */ +public static native @ByVal @Name("operator /") btVector3 divide(@Const @ByRef btVector3 v, @Cast("const btScalar") float s); + +/**\brief Return the vector inversely scaled by s */ +public static native @ByVal @Name("operator /") btVector3 divide(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the dot product between two vectors */ +public static native @Cast("btScalar") float btDot(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the distance squared between two vectors */ +public static native @Cast("btScalar") float btDistance2(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the distance between two vectors */ +public static native @Cast("btScalar") float btDistance(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the angle between two vectors */ +public static native @Cast("btScalar") float btAngle(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the cross product of two vectors */ +public static native @ByVal btVector3 btCross(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +public static native @Cast("btScalar") float btTriple(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 v3); + +/**\brief Return the linear interpolation between two vectors + * @param v1 One vector + * @param v2 The other vector + * @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */ +public static native @ByVal btVector3 lerp(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Cast("const btScalar") float t); + + + + + + + + + + + + + +public static class btVector4 extends btVector3 { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVector4(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVector4(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVector4 position(long position) { + return (btVector4)super.position(position); + } + @Override public btVector4 getPointer(long i) { + return new btVector4((Pointer)this).offsetAddress(i); + } + + public btVector4() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btVector4(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) +// #endif // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON) + + public native @ByVal btVector4 absolute4(); + + public native @Cast("btScalar") float getW(); + + public native int maxAxis4(); + + public native int minAxis4(); + + public native int closestAxis4(); + + /**\brief Set x,y,z and zero w + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + + /* void getValue(btScalar *m) const + { + m[0] = m_floats[0]; + m[1] = m_floats[1]; + m[2] =m_floats[2]; + } +*/ + /**\brief Set the values + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); +} + +/**btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef FloatPointer destVal); +public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef FloatBuffer destVal); +public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef float[] destVal); +/**btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void btSwapVector3Endian(@Const @ByRef btVector3 sourceVec, @ByRef btVector3 destVec); + +/**btUnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void btUnSwapVector3Endian(@ByRef btVector3 vector); + +public static class btVector3FloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btVector3FloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVector3FloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVector3FloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btVector3FloatData position(long position) { + return (btVector3FloatData)super.position(position); + } + @Override public btVector3FloatData getPointer(long i) { + return new btVector3FloatData((Pointer)this).offsetAddress(i); + } + + public native float m_floats(int i); public native btVector3FloatData m_floats(int i, float setter); + @MemberGetter public native FloatPointer m_floats(); +} + +public static class btVector3DoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btVector3DoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVector3DoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVector3DoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btVector3DoubleData position(long position) { + return (btVector3DoubleData)super.position(position); + } + @Override public btVector3DoubleData getPointer(long i) { + return new btVector3DoubleData((Pointer)this).offsetAddress(i); + } + + public native double m_floats(int i); public native btVector3DoubleData m_floats(int i, double setter); + @MemberGetter public native DoublePointer m_floats(); +} + + + + + + + + + + + + + + + +// #endif //BT_VECTOR3_H + + +// Parsed from LinearMath/btQuadWord.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMD_QUADWORD_H +// #define BT_SIMD_QUADWORD_H + +// #include "btScalar.h" +// #include "btMinMax.h" + +// #if defined(__CELLOS_LV2) && defined(__SPU__) +// #include +// #endif + +/**\brief The btQuadWord class is base class for btVector3 and btQuaternion. + * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword. + */ +// #ifndef USE_LIBSPE2 +@NoOffset public static class btQuadWord extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuadWord(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuadWord(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btQuadWord position(long position) { + return (btQuadWord)super.position(position); + } + @Override public btQuadWord getPointer(long i) { + return new btQuadWord((Pointer)this).offsetAddress(i); + } + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + +// #endif + + /**\brief Return the x value */ + public native @Cast("const btScalar") float getX(); + /**\brief Return the y value */ + public native @Cast("const btScalar") float getY(); + /**\brief Return the z value */ + public native @Cast("const btScalar") float getZ(); + /**\brief Set the x value */ + public native void setX(@Cast("btScalar") float _x); + /**\brief Set the y value */ + public native void setY(@Cast("btScalar") float _y); + /**\brief Set the z value */ + public native void setZ(@Cast("btScalar") float _z); + /**\brief Set the w value */ + public native void setW(@Cast("btScalar") float _w); + /**\brief Return the x value */ + public native @Cast("const btScalar") float x(); + /**\brief Return the y value */ + public native @Cast("const btScalar") float y(); + /**\brief Return the z value */ + public native @Cast("const btScalar") float z(); + /**\brief Return the w value */ + public native @Cast("const btScalar") float w(); + + //SIMD_FORCE_INLINE btScalar& operator[](int i) { return (&m_floats[0])[i]; } + //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; } + /**operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. */ + public native @Cast("btScalar*") @Name("operator btScalar*") FloatPointer asFloatPointer(); + + public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btQuadWord other); + + public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef btQuadWord other); + + /**\brief Set x,y,z and zero w + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); + + /* void getValue(btScalar *m) const + { + m[0] = m_floats[0]; + m[1] = m_floats[1]; + m[2] = m_floats[2]; + } +*/ + /**\brief Set the values + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); + /**\brief No initialization constructor */ + public btQuadWord() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**\brief Three argument constructor (zeros w) + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + public btQuadWord(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z) { super((Pointer)null); allocate(_x, _y, _z); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); + + /**\brief Initializing constructor + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public btQuadWord(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); + + /**\brief Set each element to the max of the current values and the values of another btQuadWord + * @param other The other btQuadWord to compare with + */ + public native void setMax(@Const @ByRef btQuadWord other); + /**\brief Set each element to the min of the current values and the values of another btQuadWord + * @param other The other btQuadWord to compare with + */ + public native void setMin(@Const @ByRef btQuadWord other); +} + +// #endif //BT_SIMD_QUADWORD_H + + +// Parsed from LinearMath/btQuaternion.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMD__QUATERNION_H_ +// #define BT_SIMD__QUATERNION_H_ + +// #include "btVector3.h" +// #include "btQuadWord.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btQuaternionData btQuaternionFloatData +public static final String btQuaternionDataName = "btQuaternionFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +// #ifdef BT_USE_SSE + +// #endif + +// #if defined(BT_USE_SSE) + +// #elif defined(BT_USE_NEON) + +// #endif + +/**\brief The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatrix3x3, btVector3 and btTransform. */ +public static class btQuaternion extends btQuadWord { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuaternion(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuaternion(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btQuaternion position(long position) { + return (btQuaternion)super.position(position); + } + @Override public btQuaternion getPointer(long i) { + return new btQuaternion((Pointer)this).offsetAddress(i); + } + + /**\brief No initialization constructor */ + public btQuaternion() { super((Pointer)null); allocate(); } + private native void allocate(); + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + +// #endif + + // template + // explicit Quaternion(const btScalar *v) : Tuple4(v) {} + /**\brief Constructor from scalars */ + public btQuaternion(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); + /**\brief Axis angle Constructor + * @param axis The axis which the rotation is around + * @param angle The magnitude of the rotation around the angle (Radians) */ + public btQuaternion(@Const @ByRef btVector3 _axis, @Cast("const btScalar") float _angle) { super((Pointer)null); allocate(_axis, _angle); } + private native void allocate(@Const @ByRef btVector3 _axis, @Cast("const btScalar") float _angle); + /**\brief Constructor from Euler angles + * @param yaw Angle around Y unless BT_EULER_DEFAULT_ZYX defined then Z + * @param pitch Angle around X unless BT_EULER_DEFAULT_ZYX defined then Y + * @param roll Angle around Z unless BT_EULER_DEFAULT_ZYX defined then X */ + public btQuaternion(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll) { super((Pointer)null); allocate(yaw, pitch, roll); } + private native void allocate(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); + /**\brief Set the rotation using axis angle notation + * @param axis The axis around which to rotate + * @param angle The magnitude of the rotation in Radians */ + public native void setRotation(@Const @ByRef btVector3 axis, @Cast("const btScalar") float _angle); + /**\brief Set the quaternion using Euler angles + * @param yaw Angle around Y + * @param pitch Angle around X + * @param roll Angle around Z */ + public native void setEuler(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); + /**\brief Set the quaternion using euler angles + * @param yaw Angle around Z + * @param pitch Angle around Y + * @param roll Angle around X */ + public native void setEulerZYX(@Cast("const btScalar") float yawZ, @Cast("const btScalar") float pitchY, @Cast("const btScalar") float rollX); + + /**\brief Get the euler angles from this quaternion + * @param yaw Angle around Z + * @param pitch Angle around Y + * @param roll Angle around X */ + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yawZ, @Cast("btScalar*") @ByRef FloatPointer pitchY, @Cast("btScalar*") @ByRef FloatPointer rollX); + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yawZ, @Cast("btScalar*") @ByRef FloatBuffer pitchY, @Cast("btScalar*") @ByRef FloatBuffer rollX); + public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yawZ, @Cast("btScalar*") @ByRef float[] pitchY, @Cast("btScalar*") @ByRef float[] rollX); + + /**\brief Add two quaternions + * @param q The quaternion to add to this one */ + public native @ByRef @Name("operator +=") btQuaternion addPut(@Const @ByRef btQuaternion q); + + /**\brief Subtract out a quaternion + * @param q The quaternion to subtract from this one */ + public native @ByRef @Name("operator -=") btQuaternion subtractPut(@Const @ByRef btQuaternion q); + + /**\brief Scale this quaternion + * @param s The scalar to scale by */ + public native @ByRef @Name("operator *=") btQuaternion multiplyPut(@Cast("const btScalar") float s); + + /**\brief Multiply this quaternion by q on the right + * @param q The other quaternion + * Equivilant to this = this * q */ + public native @ByRef @Name("operator *=") btQuaternion multiplyPut(@Const @ByRef btQuaternion q); + /**\brief Return the dot product between this quaternion and another + * @param q The other quaternion */ + public native @Cast("btScalar") float dot(@Const @ByRef btQuaternion q); + + /**\brief Return the length squared of the quaternion */ + public native @Cast("btScalar") float length2(); + + /**\brief Return the length of the quaternion */ + public native @Cast("btScalar") float length(); + public native @ByRef btQuaternion safeNormalize(); + /**\brief Normalize the quaternion + * Such that x^2 + y^2 + z^2 +w^2 = 1 */ + public native @ByRef btQuaternion normalize(); + + /**\brief Return a scaled version of this quaternion + * @param s The scale factor */ + public native @ByVal @Name("operator *") btQuaternion multiply(@Cast("const btScalar") float s); + + /**\brief Return an inversely scaled versionof this quaternion + * @param s The inverse scale factor */ + public native @ByVal @Name("operator /") btQuaternion divide(@Cast("const btScalar") float s); + + /**\brief Inversely scale this quaternion + * @param s The scale factor */ + public native @ByRef @Name("operator /=") btQuaternion dividePut(@Cast("const btScalar") float s); + + /**\brief Return a normalized version of this quaternion */ + public native @ByVal btQuaternion normalized(); + /**\brief Return the ***half*** angle between this quaternion and the other + * @param q The other quaternion */ + public native @Cast("btScalar") float angle(@Const @ByRef btQuaternion q); + + /**\brief Return the angle between this quaternion and the other along the shortest path + * @param q The other quaternion */ + public native @Cast("btScalar") float angleShortestPath(@Const @ByRef btQuaternion q); + + /**\brief Return the angle [0, 2Pi] of rotation represented by this quaternion */ + public native @Cast("btScalar") float getAngle(); + + /**\brief Return the angle [0, Pi] of rotation represented by this quaternion along the shortest path */ + public native @Cast("btScalar") float getAngleShortestPath(); + + /**\brief Return the axis of the rotation represented by this quaternion */ + public native @ByVal btVector3 getAxis(); + + /**\brief Return the inverse of this quaternion */ + public native @ByVal btQuaternion inverse(); + + /**\brief Return the sum of this quaternion and the other + * @param q2 The other quaternion */ + public native @ByVal @Name("operator +") btQuaternion add(@Const @ByRef btQuaternion q2); + + /**\brief Return the difference between this quaternion and the other + * @param q2 The other quaternion */ + public native @ByVal @Name("operator -") btQuaternion subtract(@Const @ByRef btQuaternion q2); + + /**\brief Return the negative of this quaternion + * This simply negates each element */ + public native @ByVal @Name("operator -") btQuaternion subtract(); + /**\todo document this and it's use */ + public native @ByVal btQuaternion farthest(@Const @ByRef btQuaternion qd); + + /**\todo document this and it's use */ + public native @ByVal btQuaternion nearest(@Const @ByRef btQuaternion qd); + + /**\brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion + * @param q The other quaternion to interpolate with + * @param t The ratio between this and q to interpolate. If t = 0 the result is this, if t=1 the result is q. + * Slerp interpolates assuming constant velocity. */ + public native @ByVal btQuaternion slerp(@Const @ByRef btQuaternion q, @Cast("const btScalar") float t); + + public static native @Const @ByRef btQuaternion getIdentity(); + + public native @Cast("const btScalar") float getW(); + + public native void serialize(@ByRef btQuaternionFloatData dataOut); + + public native void deSerialize(@Const @ByRef btQuaternionFloatData dataIn); + + public native void deSerialize(@Const @ByRef btQuaternionDoubleData dataIn); + + public native void serializeFloat(@ByRef btQuaternionFloatData dataOut); + + public native void deSerializeFloat(@Const @ByRef btQuaternionFloatData dataIn); + + public native void serializeDouble(@ByRef btQuaternionDoubleData dataOut); + + public native void deSerializeDouble(@Const @ByRef btQuaternionDoubleData dataIn); +} + +/**\brief Return the product of two quaternions */ +public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); + +public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q, @Const @ByRef btVector3 w); + +public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btVector3 w, @Const @ByRef btQuaternion q); + +/**\brief Calculate the dot product between two quaternions */ +public static native @Cast("btScalar") float dot(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); + +/**\brief Return the length of a quaternion */ +public static native @Cast("btScalar") float length(@Const @ByRef btQuaternion q); + +/**\brief Return the angle between two quaternions*/ +public static native @Cast("btScalar") float btAngle(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); + +/**\brief Return the inverse of a quaternion*/ +public static native @ByVal btQuaternion inverse(@Const @ByRef btQuaternion q); + +/**\brief Return the result of spherical linear interpolation betwen two quaternions + * @param q1 The first quaternion + * @param q2 The second quaternion + * @param t The ration between q1 and q2. t = 0 return q1, t=1 returns q2 + * Slerp assumes constant velocity between positions. */ +public static native @ByVal btQuaternion slerp(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2, @Cast("const btScalar") float t); + +public static native @ByVal btVector3 quatRotate(@Const @ByRef btQuaternion rotation, @Const @ByRef btVector3 v); + +public static native @ByVal btQuaternion shortestArcQuat(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1); + +public static native @ByVal btQuaternion shortestArcQuatNormalize2(@ByRef btVector3 v0, @ByRef btVector3 v1); + +public static class btQuaternionFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuaternionFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuaternionFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuaternionFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuaternionFloatData position(long position) { + return (btQuaternionFloatData)super.position(position); + } + @Override public btQuaternionFloatData getPointer(long i) { + return new btQuaternionFloatData((Pointer)this).offsetAddress(i); + } + + public native float m_floats(int i); public native btQuaternionFloatData m_floats(int i, float setter); + @MemberGetter public native FloatPointer m_floats(); +} + +public static class btQuaternionDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuaternionDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuaternionDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuaternionDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuaternionDoubleData position(long position) { + return (btQuaternionDoubleData)super.position(position); + } + @Override public btQuaternionDoubleData getPointer(long i) { + return new btQuaternionDoubleData((Pointer)this).offsetAddress(i); + } + + public native double m_floats(int i); public native btQuaternionDoubleData m_floats(int i, double setter); + @MemberGetter public native DoublePointer m_floats(); +} + + + + + + + + + + + + + + + +// #endif //BT_SIMD__QUATERNION_H_ + + +// Parsed from LinearMath/btMatrix3x3.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MATRIX3x3_H +// #define BT_MATRIX3x3_H + +// #include "btVector3.h" +// #include "btQuaternion.h" +// #include + +// #ifdef BT_USE_SSE +// #endif + +// #if defined(BT_USE_SSE) +// #elif defined(BT_USE_NEON) +// #endif + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btMatrix3x3Data btMatrix3x3FloatData +// #endif //BT_USE_DOUBLE_PRECISION + +/**\brief The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with btQuaternion, btTransform and btVector3. +* Make sure to only include a pure orthogonal matrix without scaling. */ +@NoOffset public static class btMatrix3x3 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMatrix3x3(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMatrix3x3(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMatrix3x3 position(long position) { + return (btMatrix3x3)super.position(position); + } + @Override public btMatrix3x3 getPointer(long i) { + return new btMatrix3x3((Pointer)this).offsetAddress(i); + } + + /** \brief No initializaion constructor */ + public btMatrix3x3() { super((Pointer)null); allocate(); } + private native void allocate(); + + // explicit btMatrix3x3(const btScalar *m) { setFromOpenGLSubMatrix(m); } + + /**\brief Constructor from Quaternion */ + public btMatrix3x3(@Const @ByRef btQuaternion q) { super((Pointer)null); allocate(q); } + private native void allocate(@Const @ByRef btQuaternion q); + /* + template + Matrix3x3(const btScalar& yaw, const btScalar& pitch, const btScalar& roll) + { + setEulerYPR(yaw, pitch, roll); + } + */ + /** \brief Constructor with row major formatting */ + public btMatrix3x3(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, + @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, + @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz) { super((Pointer)null); allocate(xx, xy, xz, yx, yy, yz, zx, zy, zz); } + private native void allocate(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, + @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, + @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz); + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + +// #else + + /** \brief Copy constructor */ + public btMatrix3x3(@Const @ByRef btMatrix3x3 other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btMatrix3x3 other); + + /** \brief Assignment Operator */ + public native @ByRef @Name("operator =") btMatrix3x3 put(@Const @ByRef btMatrix3x3 other); + + public btMatrix3x3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2) { super((Pointer)null); allocate(v0, v1, v2); } + private native void allocate(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +// #endif + + /** \brief Get a column of the matrix as a vector + * @param i Column number 0 indexed */ + public native @ByVal btVector3 getColumn(int i); + + /** \brief Get a row of the matrix as a vector + * @param i Row number 0 indexed */ + public native @Const @ByRef btVector3 getRow(int i); + + /** \brief Get a mutable reference to a row of the matrix as a vector + * @param i Row number 0 indexed */ + public native @ByRef @Name("operator []") btVector3 get(int i); + + /** \brief Get a const reference to a row of the matrix as a vector + * @param i Row number 0 indexed */ + + /** \brief Multiply by the target matrix on the right + * @param m Rotation matrix to be applied + * Equivilant to this = this * m */ + public native @ByRef @Name("operator *=") btMatrix3x3 multiplyPut(@Const @ByRef btMatrix3x3 m); + + /** \brief Adds by the target matrix on the right + * @param m matrix to be applied + * Equivilant to this = this + m */ + public native @ByRef @Name("operator +=") btMatrix3x3 addPut(@Const @ByRef btMatrix3x3 m); + + /** \brief Substractss by the target matrix on the right + * @param m matrix to be applied + * Equivilant to this = this - m */ + public native @ByRef @Name("operator -=") btMatrix3x3 subtractPut(@Const @ByRef btMatrix3x3 m); + + /** \brief Set from the rotational part of a 4x4 OpenGL matrix + * @param m A pointer to the beginning of the array of scalars*/ + public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") FloatPointer m); + public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") FloatBuffer m); + public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") float[] m); + /** \brief Set the values of the matrix explicitly (row major) + * @param xx Top left + * @param xy Top Middle + * @param xz Top Right + * @param yx Middle Left + * @param yy Middle Middle + * @param yz Middle Right + * @param zx Bottom Left + * @param zy Bottom Middle + * @param zz Bottom Right*/ + public native void setValue(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, + @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, + @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz); + + /** \brief Set the matrix from a quaternion + * @param q The Quaternion to match */ + public native void setRotation(@Const @ByRef btQuaternion q); + + /** \brief Set the matrix from euler angles using YPR around YXZ respectively + * @param yaw Yaw about Y axis + * @param pitch Pitch about X axis + * @param roll Roll about Z axis + */ + public native void setEulerYPR(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); + + /** \brief Set the matrix from euler angles YPR around ZYX axes + * @param eulerX Roll about X axis + * @param eulerY Pitch around Y axis + * @param eulerZ Yaw about Z axis + * + * These angles are used to produce a rotation matrix. The euler + * angles are applied in ZYX order. I.e a vector is first rotated + * about X then Y and then Z + **/ + public native void setEulerZYX(@Cast("btScalar") float eulerX, @Cast("btScalar") float eulerY, @Cast("btScalar") float eulerZ); + + /**\brief Set the matrix to the identity */ + public native void setIdentity(); + + /**\brief Set the matrix to the identity */ + public native void setZero(); + + public static native @Const @ByRef btMatrix3x3 getIdentity(); + + /**\brief Fill the rotational part of an OpenGL matrix and clear the shear/perspective + * @param m The array to be filled */ + public native void getOpenGLSubMatrix(@Cast("btScalar*") FloatPointer m); + public native void getOpenGLSubMatrix(@Cast("btScalar*") FloatBuffer m); + public native void getOpenGLSubMatrix(@Cast("btScalar*") float[] m); + + /**\brief Get the matrix represented as a quaternion + * @param q The quaternion which will be set */ + public native void getRotation(@ByRef btQuaternion q); + + /**\brief Get the matrix represented as euler angles around YXZ, roundtrip with setEulerYPR + * @param yaw Yaw around Y axis + * @param pitch Pitch around X axis + * @param roll around Z axis */ + public native void getEulerYPR(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll); + public native void getEulerYPR(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll); + public native void getEulerYPR(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll); + + /**\brief Get the matrix represented as euler angles around ZYX + * @param yaw Yaw around Z axis + * @param pitch Pitch around Y axis + * @param roll around X axis + * @param solution_number Which solution of two possible solutions ( 1 or 2) are possible values*/ + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll); + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll); + public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll); + + /**\brief Create a scaled copy of the matrix + * @param s Scaling vector The elements of the vector will scale each column */ + + public native @ByVal btMatrix3x3 scaled(@Const @ByRef btVector3 s); + + /**\brief Return the determinant of the matrix */ + public native @Cast("btScalar") float determinant(); + /**\brief Return the adjoint of the matrix */ + public native @ByVal btMatrix3x3 adjoint(); + /**\brief Return the matrix with all values non negative */ + public native @ByVal btMatrix3x3 absolute(); + /**\brief Return the transpose of the matrix */ + public native @ByVal btMatrix3x3 transpose(); + /**\brief Return the inverse of the matrix */ + public native @ByVal btMatrix3x3 inverse(); + + /** Solve A * x = b, where b is a column vector. This is more efficient + * than computing the inverse in one-shot cases. + * Solve33 is from Box2d, thanks to Erin Catto, */ + public native @ByVal btVector3 solve33(@Const @ByRef btVector3 b); + + public native @ByVal btMatrix3x3 transposeTimes(@Const @ByRef btMatrix3x3 m); + public native @ByVal btMatrix3x3 timesTranspose(@Const @ByRef btMatrix3x3 m); + + public native @Cast("btScalar") float tdotx(@Const @ByRef btVector3 v); + public native @Cast("btScalar") float tdoty(@Const @ByRef btVector3 v); + public native @Cast("btScalar") float tdotz(@Const @ByRef btVector3 v); + + /**extractRotation is from "A robust method to extract the rotational part of deformations" + * See http://dl.acm.org/citation.cfm?doid=2994258.2994269 + * decomposes a matrix A in a orthogonal matrix R and a + * symmetric matrix S: + * A = R*S. + * note that R can include both rotation and scaling. */ + public native void extractRotation(@ByRef btQuaternion q, @Cast("btScalar") float tolerance/*=1.0e-9*/, int maxIter/*=100*/); + public native void extractRotation(@ByRef btQuaternion q); + + /**\brief diagonalizes this matrix by the Jacobi method. + * @param rot stores the rotation from the coordinate system in which the matrix is diagonal to the original + * coordinate system, i.e., old_this = rot * new_this * rot^T. + * @param threshold See iteration + * @param iteration The iteration stops when all off-diagonal elements are less than the threshold multiplied + * by the sum of the absolute values of the diagonal, or when maxSteps have been executed. + * + * Note that this matrix is assumed to be symmetric. + */ + public native void diagonalize(@ByRef btMatrix3x3 rot, @Cast("btScalar") float threshold, int maxSteps); + + /**\brief Calculate the matrix cofactor + * @param r1 The first row to use for calculating the cofactor + * @param c1 The first column to use for calculating the cofactor + * @param r1 The second row to use for calculating the cofactor + * @param c1 The second column to use for calculating the cofactor + * See http://en.wikipedia.org/wiki/Cofactor_(linear_algebra) for more details + */ + public native @Cast("btScalar") float cofac(int r1, int c1, int r2, int c2); + + public native void serialize(@ByRef btMatrix3x3FloatData dataOut); + + public native void serializeFloat(@ByRef btMatrix3x3FloatData dataOut); + + public native void deSerialize(@Const @ByRef btMatrix3x3FloatData dataIn); + + public native void deSerializeFloat(@Const @ByRef btMatrix3x3FloatData dataIn); + + public native void deSerializeDouble(@Const @ByRef btMatrix3x3DoubleData dataIn); +} + + + + + +public static native @ByVal @Name("operator *") btMatrix3x3 multiply(@Const @ByRef btMatrix3x3 m, @Cast("const btScalar") float k); + +public static native @ByVal @Name("operator +") btMatrix3x3 add(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); + +public static native @ByVal @Name("operator -") btMatrix3x3 subtract(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); + + + + + + + + + + + + + + + + + +public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btMatrix3x3 m, @Const @ByRef btVector3 v); + +public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v, @Const @ByRef btMatrix3x3 m); + +public static native @ByVal @Name("operator *") btMatrix3x3 multiply(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); + +/* +SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const btMatrix3x3& m2) { +return btMatrix3x3( +m1[0][0] * m2[0][0] + m1[1][0] * m2[1][0] + m1[2][0] * m2[2][0], +m1[0][0] * m2[0][1] + m1[1][0] * m2[1][1] + m1[2][0] * m2[2][1], +m1[0][0] * m2[0][2] + m1[1][0] * m2[1][2] + m1[2][0] * m2[2][2], +m1[0][1] * m2[0][0] + m1[1][1] * m2[1][0] + m1[2][1] * m2[2][0], +m1[0][1] * m2[0][1] + m1[1][1] * m2[1][1] + m1[2][1] * m2[2][1], +m1[0][1] * m2[0][2] + m1[1][1] * m2[1][2] + m1[2][1] * m2[2][2], +m1[0][2] * m2[0][0] + m1[1][2] * m2[1][0] + m1[2][2] * m2[2][0], +m1[0][2] * m2[0][1] + m1[1][2] * m2[1][1] + m1[2][2] * m2[2][1], +m1[0][2] * m2[0][2] + m1[1][2] * m2[1][2] + m1[2][2] * m2[2][2]); +} +*/ + +/**\brief Equality operator between two matrices +* It will test all elements are equal. */ +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); + +/**for serialization */ +public static class btMatrix3x3FloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMatrix3x3FloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMatrix3x3FloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMatrix3x3FloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMatrix3x3FloatData position(long position) { + return (btMatrix3x3FloatData)super.position(position); + } + @Override public btMatrix3x3FloatData getPointer(long i) { + return new btMatrix3x3FloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_el(int i); public native btMatrix3x3FloatData m_el(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_el(); +} + +/**for serialization */ +public static class btMatrix3x3DoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMatrix3x3DoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMatrix3x3DoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMatrix3x3DoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMatrix3x3DoubleData position(long position) { + return (btMatrix3x3DoubleData)super.position(position); + } + @Override public btMatrix3x3DoubleData getPointer(long i) { + return new btMatrix3x3DoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3DoubleData m_el(int i); public native btMatrix3x3DoubleData m_el(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_el(); +} + + + + + + + + + + + +// #endif //BT_MATRIX3x3_H + + +// Parsed from LinearMath/btTransform.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRANSFORM_H +// #define BT_TRANSFORM_H + +// #include "btMatrix3x3.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btTransformData btTransformFloatData +// #endif + +/**\brief The btTransform class supports rigid transforms with only translation and rotation and no scaling/shear. + *It can be used in combination with btVector3, btQuaternion and btMatrix3x3 linear algebra classes. */ +@NoOffset public static class btTransform extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTransform(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTransform(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTransform position(long position) { + return (btTransform)super.position(position); + } + @Override public btTransform getPointer(long i) { + return new btTransform((Pointer)this).offsetAddress(i); + } + + /**\brief No initialization constructor */ + public btTransform() { super((Pointer)null); allocate(); } + private native void allocate(); + /**\brief Constructor from btQuaternion (optional btVector3 ) + * @param q Rotation from quaternion + * @param c Translation from Vector (default 0,0,0) */ + public btTransform(@Const @ByRef btQuaternion q, + @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c) { super((Pointer)null); allocate(q, c); } + private native void allocate(@Const @ByRef btQuaternion q, + @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c); + public btTransform(@Const @ByRef btQuaternion q) { super((Pointer)null); allocate(q); } + private native void allocate(@Const @ByRef btQuaternion q); + + /**\brief Constructor from btMatrix3x3 (optional btVector3) + * @param b Rotation from Matrix + * @param c Translation from Vector default (0,0,0)*/ + public btTransform(@Const @ByRef btMatrix3x3 b, + @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c) { super((Pointer)null); allocate(b, c); } + private native void allocate(@Const @ByRef btMatrix3x3 b, + @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c); + public btTransform(@Const @ByRef btMatrix3x3 b) { super((Pointer)null); allocate(b); } + private native void allocate(@Const @ByRef btMatrix3x3 b); + /**\brief Copy constructor */ + public btTransform(@Const @ByRef btTransform other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btTransform other); + /**\brief Assignment Operator */ + public native @ByRef @Name("operator =") btTransform put(@Const @ByRef btTransform other); + + /**\brief Set the current transform as the value of the product of two transforms + * @param t1 Transform 1 + * @param t2 Transform 2 + * This = Transform1 * Transform2 */ + public native void mult(@Const @ByRef btTransform t1, @Const @ByRef btTransform t2); + + /* void multInverseLeft(const btTransform& t1, const btTransform& t2) { + btVector3 v = t2.m_origin - t1.m_origin; + m_basis = btMultTransposeLeft(t1.m_basis, t2.m_basis); + m_origin = v * t1.m_basis; + } + */ + + /**\brief Return the transform of the vector */ + public native @ByVal @Name("operator ()") btVector3 apply(@Const @ByRef btVector3 x); + + /**\brief Return the transform of the vector */ + public native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 x); + + /**\brief Return the transform of the btQuaternion */ + public native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q); + + /**\brief Return the basis matrix for the rotation */ + public native @ByRef btMatrix3x3 getBasis(); + /**\brief Return the basis matrix for the rotation */ + + /**\brief Return the origin vector translation */ + public native @ByRef btVector3 getOrigin(); + /**\brief Return the origin vector translation */ + + /**\brief Return a quaternion representing the rotation */ + public native @ByVal btQuaternion getRotation(); + + /**\brief Set from an array + * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */ + public native void setFromOpenGLMatrix(@Cast("const btScalar*") FloatPointer m); + public native void setFromOpenGLMatrix(@Cast("const btScalar*") FloatBuffer m); + public native void setFromOpenGLMatrix(@Cast("const btScalar*") float[] m); + + /**\brief Fill an array representation + * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */ + public native void getOpenGLMatrix(@Cast("btScalar*") FloatPointer m); + public native void getOpenGLMatrix(@Cast("btScalar*") FloatBuffer m); + public native void getOpenGLMatrix(@Cast("btScalar*") float[] m); + + /**\brief Set the translational element + * @param origin The vector to set the translation to */ + public native void setOrigin(@Const @ByRef btVector3 origin); + + public native @ByVal btVector3 invXform(@Const @ByRef btVector3 inVec); + + /**\brief Set the rotational element by btMatrix3x3 */ + public native void setBasis(@Const @ByRef btMatrix3x3 basis); + + /**\brief Set the rotational element by btQuaternion */ + public native void setRotation(@Const @ByRef btQuaternion q); + + /**\brief Set this transformation to the identity */ + public native void setIdentity(); + + /**\brief Multiply this Transform by another(this = this * another) + * @param t The other transform */ + public native @ByRef @Name("operator *=") btTransform multiplyPut(@Const @ByRef btTransform t); + + /**\brief Return the inverse of this transform */ + public native @ByVal btTransform inverse(); + + /**\brief Return the inverse of this transform times the other transform + * @param t The other transform + * return this.inverse() * the other */ + public native @ByVal btTransform inverseTimes(@Const @ByRef btTransform t); + + /**\brief Return the product of this transform and the other */ + public native @ByVal @Name("operator *") btTransform multiply(@Const @ByRef btTransform t); + + /**\brief Return an identity transform */ + public static native @Const @ByRef btTransform getIdentity(); + + public native void serialize(@ByRef btTransformFloatData dataOut); + + public native void serializeFloat(@ByRef btTransformFloatData dataOut); + + public native void deSerialize(@Const @ByRef btTransformFloatData dataIn); + + public native void deSerializeDouble(@Const @ByRef btTransformDoubleData dataIn); + + public native void deSerializeFloat(@Const @ByRef btTransformFloatData dataIn); +} + + + + + + + +/**\brief Test if two transforms have all elements equal */ +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btTransform t1, @Const @ByRef btTransform t2); + +/**for serialization */ +public static class btTransformFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTransformFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTransformFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTransformFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTransformFloatData position(long position) { + return (btTransformFloatData)super.position(position); + } + @Override public btTransformFloatData getPointer(long i) { + return new btTransformFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3FloatData m_basis(); public native btTransformFloatData m_basis(btMatrix3x3FloatData setter); + public native @ByRef btVector3FloatData m_origin(); public native btTransformFloatData m_origin(btVector3FloatData setter); +} + +public static class btTransformDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTransformDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTransformDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTransformDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTransformDoubleData position(long position) { + return (btTransformDoubleData)super.position(position); + } + @Override public btTransformDoubleData getPointer(long i) { + return new btTransformDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3DoubleData m_basis(); public native btTransformDoubleData m_basis(btMatrix3x3DoubleData setter); + public native @ByRef btVector3DoubleData m_origin(); public native btTransformDoubleData m_origin(btVector3DoubleData setter); +} + + + + + + + + + + + +// #endif //BT_TRANSFORM_H + + +// Parsed from LinearMath/btAlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBJECT_ARRAY__ +// #define BT_OBJECT_ARRAY__ + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +// #include "btAlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW + * then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int BT_USE_PLACEMENT_NEW = 1; +//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef BT_USE_MEMCPY +// #include +// #include +// #endif //BT_USE_MEMCPY + +// #ifdef BT_USE_PLACEMENT_NEW +// #include //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset public static class btAlignedObjectArray_btVector3 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btVector3(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btVector3(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btVector3 position(long position) { + return (btAlignedObjectArray_btVector3)super.position(position); + } + @Override public btAlignedObjectArray_btVector3 getPointer(long i) { + return new btAlignedObjectArray_btVector3((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btVector3 put(@Const @ByRef btAlignedObjectArray_btVector3 other); + public btAlignedObjectArray_btVector3() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btVector3(@Const @ByRef btAlignedObjectArray_btVector3 otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btVector3 otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btVector3 at(int n); + + public native @ByRef @Name("operator []") btVector3 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btVector3()") btVector3 fillData); + public native void resize(int newsize); + public native @ByRef btVector3 expandNonInitializing(); + + public native @ByRef btVector3 expand(@Const @ByRef(nullValue = "btVector3()") btVector3 fillValue); + public native @ByRef btVector3 expand(); + + public native void push_back(@Const @ByRef btVector3 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Const @ByRef btVector3 key); + + public native int findLinearSearch(@Const @ByRef btVector3 key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Const @ByRef btVector3 key); + + public native void removeAtIndex(int index); + public native void remove(@Const @ByRef btVector3 key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btVector3 otherArray); +} +@Name("btAlignedObjectArray") @NoOffset public static class btAlignedObjectArray_btScalar extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btScalar(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btScalar(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btScalar position(long position) { + return (btAlignedObjectArray_btScalar)super.position(position); + } + @Override public btAlignedObjectArray_btScalar getPointer(long i) { + return new btAlignedObjectArray_btScalar((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btScalar put(@Const @ByRef btAlignedObjectArray_btScalar other); + public btAlignedObjectArray_btScalar() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btScalar(@Const @ByRef btAlignedObjectArray_btScalar otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btScalar otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @Cast("btScalar*") @ByRef FloatPointer at(int n); + + public native @Cast("btScalar*") @ByRef @Name("operator []") FloatPointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Cast("const btScalar") float fillData/*=btScalar()*/); + public native void resize(int newsize); + public native @Cast("btScalar*") @ByRef FloatPointer expandNonInitializing(); + + public native @Cast("btScalar*") @ByRef FloatPointer expand(@Cast("const btScalar") float fillValue/*=btScalar()*/); + public native @Cast("btScalar*") @ByRef FloatPointer expand(); + + public native void push_back(@Cast("const btScalar") float _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Cast("const btScalar") float key); + + public native int findLinearSearch(@Cast("const btScalar") float key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Cast("const btScalar") float key); + + public native void removeAtIndex(int index); + public native void remove(@Cast("const btScalar") float key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btScalar otherArray); +} + +// #endif //BT_OBJECT_ARRAY__ + + +// Parsed from LinearMath/btHashMap.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_HASH_MAP_H +// #define BT_HASH_MAP_H + +// #include +// #include "btAlignedObjectArray.h" + +/**very basic hashable string implementation, compatible with btHashMap */ +@NoOffset public static class btHashString extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashString(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHashString(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btHashString position(long position) { + return (btHashString)super.position(position); + } + @Override public btHashString getPointer(long i) { + return new btHashString((Pointer)this).offsetAddress(i); + } + + public native @StdString BytePointer m_string1(); public native btHashString m_string1(BytePointer setter); + public native @Cast("unsigned int") int m_hash(); public native btHashString m_hash(int setter); + + public native @Cast("unsigned int") int getHash(); + + public btHashString() { super((Pointer)null); allocate(); } + private native void allocate(); + public btHashString(@Cast("const char*") BytePointer name) { super((Pointer)null); allocate(name); } + private native void allocate(@Cast("const char*") BytePointer name); + public btHashString(String name) { super((Pointer)null); allocate(name); } + private native void allocate(String name); + + public native @Cast("bool") boolean equals(@Const @ByRef btHashString other); +} + +@MemberGetter public static native int BT_HASH_NULL(); + +@NoOffset public static class btHashInt extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashInt(Pointer p) { super(p); } + + public btHashInt() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btHashInt(int uid) { super((Pointer)null); allocate(uid); } + private native void allocate(int uid); + + public native int getUid1(); + + public native void setUid1(int uid); + + public native @Cast("bool") boolean equals(@Const @ByRef btHashInt other); + //to our success + public native @Cast("unsigned int") int getHash(); +} + +public static class btHashPtr extends Pointer { + static { Loader.load(); } + + public btHashPtr(@Const Pointer ptr) { super((Pointer)null); allocate(ptr); } + private native void allocate(@Const Pointer ptr); + + public native @Const Pointer getPointer(); + + public native @Cast("bool") boolean equals(@Const @ByRef btHashPtr other); + + //to our success + public native @Cast("unsigned int") int getHash(); +} + +/**The btHashMap template class implements a generic and lightweight hashmap. + * A basic sample of how to use btHashMap is located in Demos\BasicDemo\main.cpp */ +@Name("btHashMap") public static class btHashMap_btHashPtr_voidPointer extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHashMap_btHashPtr_voidPointer() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHashMap_btHashPtr_voidPointer(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashMap_btHashPtr_voidPointer(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHashMap_btHashPtr_voidPointer position(long position) { + return (btHashMap_btHashPtr_voidPointer)super.position(position); + } + @Override public btHashMap_btHashPtr_voidPointer getPointer(long i) { + return new btHashMap_btHashPtr_voidPointer((Pointer)this).offsetAddress(i); + } + + public native void insert(@Const @ByRef btHashPtr key, @ByPtrRef Pointer value); + + public native void remove(@Const @ByRef btHashPtr key); + + public native int size(); + + public native @Cast("void**") PointerPointer getAtIndex(int index); + + public native @ByVal btHashPtr getKeyAtIndex(int index); + + public native @Cast("void**") @Name("operator []") PointerPointer get(@Const @ByRef btHashPtr key); + + public native @Cast("void**") PointerPointer find(@Const @ByRef btHashPtr key); + + public native int findIndex(@Const @ByRef btHashPtr key); + + public native void clear(); +} + +// #endif //BT_HASH_MAP_H + + +// Parsed from LinearMath/btSerializer.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SERIALIZER_H +// #define BT_SERIALIZER_H + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +// #include "btHashMap.h" + +// #if !defined(__CELLOS_LV2__) && !defined(__MWERKS__) +// #include +// #endif +// #include + +public static native @Cast("char") byte sBulletDNAstr(int i); public static native void sBulletDNAstr(int i, byte setter); +@MemberGetter public static native @Cast("char*") BytePointer sBulletDNAstr(); +public static native int sBulletDNAlen(); public static native void sBulletDNAlen(int setter); +public static native @Cast("char") byte sBulletDNAstr64(int i); public static native void sBulletDNAstr64(int i, byte setter); +@MemberGetter public static native @Cast("char*") BytePointer sBulletDNAstr64(); +public static native int sBulletDNAlen64(); public static native void sBulletDNAlen64(int setter); + +public static native int btStrLen(@Cast("const char*") BytePointer str); +public static native int btStrLen(String str); + +public static class btChunk extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btChunk() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btChunk(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btChunk(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btChunk position(long position) { + return (btChunk)super.position(position); + } + @Override public btChunk getPointer(long i) { + return new btChunk((Pointer)this).offsetAddress(i); + } + + public native int m_chunkCode(); public native btChunk m_chunkCode(int setter); + public native int m_length(); public native btChunk m_length(int setter); + public native Pointer m_oldPtr(); public native btChunk m_oldPtr(Pointer setter); + public native int m_dna_nr(); public native btChunk m_dna_nr(int setter); + public native int m_number(); public native btChunk m_number(int setter); +} + +/** enum btSerializationFlags */ +public static final int + BT_SERIALIZE_NO_BVH = 1, + BT_SERIALIZE_NO_TRIANGLEINFOMAP = 2, + BT_SERIALIZE_NO_DUPLICATE_ASSERT = 4, + BT_SERIALIZE_CONTACT_MANIFOLDS = 8; + +public static class btSerializer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSerializer(Pointer p) { super(p); } + + + public native @Cast("const unsigned char*") BytePointer getBufferPointer(); + + public native int getCurrentBufferSize(); + + public native @Name("allocate") btChunk _allocate(@Cast("size_t") long size, int numElements); + + public native void finalizeChunk(btChunk chunk, @Cast("const char*") BytePointer structType, int chunkCode, Pointer oldPtr); + public native void finalizeChunk(btChunk chunk, String structType, int chunkCode, Pointer oldPtr); + + public native Pointer findPointer(Pointer oldPtr); + + public native Pointer getUniquePointer(Pointer oldPtr); + + public native void startSerialization(); + + public native void finishSerialization(); + + public native @Cast("const char*") BytePointer findNameForPointer(@Const Pointer ptr); + + public native void registerNameForPointer(@Const Pointer ptr, @Cast("const char*") BytePointer name); + public native void registerNameForPointer(@Const Pointer ptr, String name); + + public native void serializeName(@Cast("const char*") BytePointer ptr); + public native void serializeName(String ptr); + + public native int getSerializationFlags(); + + public native void setSerializationFlags(int flags); + + public native int getNumChunks(); + + public native @Const btChunk getChunk(int chunkIndex); +} + +public static final int BT_HEADER_LENGTH = 12; +// #if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__) +// #define BT_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d)) +// #else +// #define BT_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a)) +// #endif + +public static native @MemberGetter int BT_MULTIBODY_CODE(); +public static final int BT_MULTIBODY_CODE = BT_MULTIBODY_CODE(); +public static native @MemberGetter int BT_MB_LINKCOLLIDER_CODE(); +public static final int BT_MB_LINKCOLLIDER_CODE = BT_MB_LINKCOLLIDER_CODE(); +public static native @MemberGetter int BT_SOFTBODY_CODE(); +public static final int BT_SOFTBODY_CODE = BT_SOFTBODY_CODE(); +public static native @MemberGetter int BT_COLLISIONOBJECT_CODE(); +public static final int BT_COLLISIONOBJECT_CODE = BT_COLLISIONOBJECT_CODE(); +public static native @MemberGetter int BT_RIGIDBODY_CODE(); +public static final int BT_RIGIDBODY_CODE = BT_RIGIDBODY_CODE(); +public static native @MemberGetter int BT_CONSTRAINT_CODE(); +public static final int BT_CONSTRAINT_CODE = BT_CONSTRAINT_CODE(); +public static native @MemberGetter int BT_BOXSHAPE_CODE(); +public static final int BT_BOXSHAPE_CODE = BT_BOXSHAPE_CODE(); +public static native @MemberGetter int BT_QUANTIZED_BVH_CODE(); +public static final int BT_QUANTIZED_BVH_CODE = BT_QUANTIZED_BVH_CODE(); +public static native @MemberGetter int BT_TRIANLGE_INFO_MAP(); +public static final int BT_TRIANLGE_INFO_MAP = BT_TRIANLGE_INFO_MAP(); +public static native @MemberGetter int BT_SHAPE_CODE(); +public static final int BT_SHAPE_CODE = BT_SHAPE_CODE(); +public static native @MemberGetter int BT_ARRAY_CODE(); +public static final int BT_ARRAY_CODE = BT_ARRAY_CODE(); +public static native @MemberGetter int BT_SBMATERIAL_CODE(); +public static final int BT_SBMATERIAL_CODE = BT_SBMATERIAL_CODE(); +public static native @MemberGetter int BT_SBNODE_CODE(); +public static final int BT_SBNODE_CODE = BT_SBNODE_CODE(); +public static native @MemberGetter int BT_DYNAMICSWORLD_CODE(); +public static final int BT_DYNAMICSWORLD_CODE = BT_DYNAMICSWORLD_CODE(); +public static native @MemberGetter int BT_CONTACTMANIFOLD_CODE(); +public static final int BT_CONTACTMANIFOLD_CODE = BT_CONTACTMANIFOLD_CODE(); +public static native @MemberGetter int BT_DNA_CODE(); +public static final int BT_DNA_CODE = BT_DNA_CODE(); + +public static class btPointerUid extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPointerUid() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPointerUid(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPointerUid(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPointerUid position(long position) { + return (btPointerUid)super.position(position); + } + @Override public btPointerUid getPointer(long i) { + return new btPointerUid((Pointer)this).offsetAddress(i); + } + + public native Pointer m_ptr(); public native btPointerUid m_ptr(Pointer setter); + public native int m_uniqueIds(int i); public native btPointerUid m_uniqueIds(int i, int setter); + @MemberGetter public native IntPointer m_uniqueIds(); +} + +/**The btDefaultSerializer is the main Bullet serialization class. + * The constructor takes an optional argument for backwards compatibility, it is recommended to leave this empty/zero. */ +@NoOffset public static class btDefaultSerializer extends btSerializer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultSerializer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultSerializer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultSerializer position(long position) { + return (btDefaultSerializer)super.position(position); + } + @Override public btDefaultSerializer getPointer(long i) { + return new btDefaultSerializer((Pointer)this).offsetAddress(i); + } + + @MemberGetter public native @ByRef btHashMap_btHashPtr_voidPointer m_skipPointers(); + + public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") BytePointer buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } + private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") BytePointer buffer/*=0*/); + public btDefaultSerializer() { super((Pointer)null); allocate(); } + private native void allocate(); + public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") ByteBuffer buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } + private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") ByteBuffer buffer/*=0*/); + public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") byte[] buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } + private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") byte[] buffer/*=0*/); + + public static native int getMemoryDnaSizeInBytes(); + public static native @Cast("const char*") BytePointer getMemoryDna(); + + public native void insertHeader(); + + public native void writeHeader(@Cast("unsigned char*") BytePointer buffer); + public native void writeHeader(@Cast("unsigned char*") ByteBuffer buffer); + public native void writeHeader(@Cast("unsigned char*") byte[] buffer); + + public native void startSerialization(); + + public native void finishSerialization(); + + public native Pointer getUniquePointer(Pointer oldPtr); + + public native @Cast("const unsigned char*") BytePointer getBufferPointer(); + + public native int getCurrentBufferSize(); + + public native void finalizeChunk(btChunk chunk, @Cast("const char*") BytePointer structType, int chunkCode, Pointer oldPtr); + public native void finalizeChunk(btChunk chunk, String structType, int chunkCode, Pointer oldPtr); + + public native @Cast("unsigned char*") BytePointer internalAlloc(@Cast("size_t") long size); + + public native @Name("allocate") btChunk _allocate(@Cast("size_t") long size, int numElements); + + public native @Cast("const char*") BytePointer findNameForPointer(@Const Pointer ptr); + + public native void registerNameForPointer(@Const Pointer ptr, @Cast("const char*") BytePointer name); + public native void registerNameForPointer(@Const Pointer ptr, String name); + + public native void serializeName(@Cast("const char*") BytePointer name); + public native void serializeName(String name); + + public native int getSerializationFlags(); + + public native void setSerializationFlags(int flags); + public native int getNumChunks(); + + public native @Const btChunk getChunk(int chunkIndex); +} + +/**In general it is best to use btDefaultSerializer, + * in particular when writing the data to disk or sending it over the network. + * The btInMemorySerializer is experimental and only suitable in a few cases. + * The btInMemorySerializer takes a shortcut and can be useful to create a deep-copy + * of objects. There will be a demo on how to use the btInMemorySerializer. */ +// #ifdef ENABLE_INMEMORY_SERIALIZER +// #endif //ENABLE_INMEMORY_SERIALIZER + +// #endif //BT_SERIALIZER_H + + +// Parsed from LinearMath/btIDebugDraw.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_IDEBUG_DRAW__H +// #define BT_IDEBUG_DRAW__H + +// #include "btVector3.h" +// #include "btTransform.h" + +/**The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations. + * Typical use case: create a debug drawer object, and assign it to a btCollisionWorld or btDynamicsWorld using setDebugDrawer and call debugDrawWorld. + * A class that implements the btIDebugDraw interface will need to provide non-empty implementations of the the drawLine and getDebugMode methods at a minimum. + * For color arguments the X,Y,Z components refer to Red, Green and Blue each in the range [0..1] */ +public static class btIDebugDraw extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIDebugDraw(Pointer p) { super(p); } + + @NoOffset public static class DefaultColors extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DefaultColors(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DefaultColors(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public DefaultColors position(long position) { + return (DefaultColors)super.position(position); + } + @Override public DefaultColors getPointer(long i) { + return new DefaultColors((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_activeObject(); public native DefaultColors m_activeObject(btVector3 setter); + public native @ByRef btVector3 m_deactivatedObject(); public native DefaultColors m_deactivatedObject(btVector3 setter); + public native @ByRef btVector3 m_wantsDeactivationObject(); public native DefaultColors m_wantsDeactivationObject(btVector3 setter); + public native @ByRef btVector3 m_disabledDeactivationObject(); public native DefaultColors m_disabledDeactivationObject(btVector3 setter); + public native @ByRef btVector3 m_disabledSimulationObject(); public native DefaultColors m_disabledSimulationObject(btVector3 setter); + public native @ByRef btVector3 m_aabb(); public native DefaultColors m_aabb(btVector3 setter); + public native @ByRef btVector3 m_contactPoint(); public native DefaultColors m_contactPoint(btVector3 setter); + + public DefaultColors() { super((Pointer)null); allocate(); } + private native void allocate(); + } + + /** enum btIDebugDraw::DebugDrawModes */ + public static final int + DBG_NoDebug = 0, + DBG_DrawWireframe = 1, + DBG_DrawAabb = 2, + DBG_DrawFeaturesText = 4, + DBG_DrawContactPoints = 8, + DBG_NoDeactivation = 16, + DBG_NoHelpText = 32, + DBG_DrawText = 64, + DBG_ProfileTimings = 128, + DBG_EnableSatComparison = 256, + DBG_DisableBulletLCP = 512, + DBG_EnableCCD = 1024, + DBG_DrawConstraints = (1 << 11), + DBG_DrawConstraintLimits = (1 << 12), + DBG_FastWireframe = (1 << 13), + DBG_DrawNormals = (1 << 14), + DBG_DrawFrames = (1 << 15), + DBG_MAX_DEBUG_DRAW_MODE = (1 << 15) + 1; + + public native @ByVal DefaultColors getDefaultColors(); + /**the default implementation for setDefaultColors has no effect. A derived class can implement it and store the colors. */ + public native void setDefaultColors(@Const @ByRef DefaultColors arg0); + + public native void drawLine(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 color); + + public native void drawLine(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 fromColor, @Const @ByRef btVector3 toColor); + + public native void drawSphere(@Cast("btScalar") float radius, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void drawSphere(@Const @ByRef btVector3 p, @Cast("btScalar") float radius, @Const @ByRef btVector3 color); + + public native void drawTriangle(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 arg3, @Const @ByRef btVector3 arg4, @Const @ByRef btVector3 arg5, @Const @ByRef btVector3 color, @Cast("btScalar") float alpha); + public native void drawTriangle(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 color, @Cast("btScalar") float arg4); + + public native void drawContactPoint(@Const @ByRef btVector3 PointOnB, @Const @ByRef btVector3 normalOnB, @Cast("btScalar") float distance, int lifeTime, @Const @ByRef btVector3 color); + + public native void reportErrorWarning(@Cast("const char*") BytePointer warningString); + public native void reportErrorWarning(String warningString); + + public native void draw3dText(@Const @ByRef btVector3 location, @Cast("const char*") BytePointer textString); + public native void draw3dText(@Const @ByRef btVector3 location, String textString); + + public native void setDebugMode(int debugMode); + + public native int getDebugMode(); + + public native void drawAabb(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 color); + public native void drawTransform(@Const @ByRef btTransform transform, @Cast("btScalar") float orthoLen); + + public native void drawArc(@Const @ByRef btVector3 center, @Const @ByRef btVector3 normal, @Const @ByRef btVector3 axis, @Cast("btScalar") float radiusA, @Cast("btScalar") float radiusB, @Cast("btScalar") float minAngle, @Cast("btScalar") float maxAngle, + @Const @ByRef btVector3 color, @Cast("bool") boolean drawSect, @Cast("btScalar") float stepDegrees/*=btScalar(10.f)*/); + public native void drawArc(@Const @ByRef btVector3 center, @Const @ByRef btVector3 normal, @Const @ByRef btVector3 axis, @Cast("btScalar") float radiusA, @Cast("btScalar") float radiusB, @Cast("btScalar") float minAngle, @Cast("btScalar") float maxAngle, + @Const @ByRef btVector3 color, @Cast("bool") boolean drawSect); + public native void drawSpherePatch(@Const @ByRef btVector3 center, @Const @ByRef btVector3 up, @Const @ByRef btVector3 axis, @Cast("btScalar") float radius, + @Cast("btScalar") float minTh, @Cast("btScalar") float maxTh, @Cast("btScalar") float minPs, @Cast("btScalar") float maxPs, @Const @ByRef btVector3 color, @Cast("btScalar") float stepDegrees/*=btScalar(10.f)*/, @Cast("bool") boolean drawCenter/*=true*/); + public native void drawSpherePatch(@Const @ByRef btVector3 center, @Const @ByRef btVector3 up, @Const @ByRef btVector3 axis, @Cast("btScalar") float radius, + @Cast("btScalar") float minTh, @Cast("btScalar") float maxTh, @Cast("btScalar") float minPs, @Cast("btScalar") float maxPs, @Const @ByRef btVector3 color); + + public native void drawBox(@Const @ByRef btVector3 bbMin, @Const @ByRef btVector3 bbMax, @Const @ByRef btVector3 color); + public native void drawBox(@Const @ByRef btVector3 bbMin, @Const @ByRef btVector3 bbMax, @Const @ByRef btTransform trans, @Const @ByRef btVector3 color); + + public native void drawCapsule(@Cast("btScalar") float radius, @Cast("btScalar") float halfHeight, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void drawCylinder(@Cast("btScalar") float radius, @Cast("btScalar") float halfHeight, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void drawCone(@Cast("btScalar") float radius, @Cast("btScalar") float height, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void drawPlane(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConst, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void clearLines(); + + public native void flushLines(); +} + +// #endif //BT_IDEBUG_DRAW__H + + +// Parsed from LinearMath/btQuickprof.h + + +/*************************************************************************************************** +** +** Real-Time Hierarchical Profiling for Game Programming Gems 3 +** +** by Greg Hjelstrom & Byon Garrabrant +** +***************************************************************************************************/ + +// Credits: The Clock class was inspired by the Timer classes in +// Ogre (www.ogre3d.org). + +// #ifndef BT_QUICK_PROF_H +// #define BT_QUICK_PROF_H + +// #include "btScalar.h" +public static final int USE_BT_CLOCK = 1; + +// #ifdef USE_BT_CLOCK + +/**The btClock is a portable basic clock that measures accurate time in seconds, use for profiling. */ +@NoOffset public static class btClock extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btClock(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btClock(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btClock position(long position) { + return (btClock)super.position(position); + } + @Override public btClock getPointer(long i) { + return new btClock((Pointer)this).offsetAddress(i); + } + + public btClock() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btClock(@Const @ByRef btClock other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btClock other); + public native @ByRef @Name("operator =") btClock put(@Const @ByRef btClock other); + + /** Resets the initial reference time. */ + public native void reset(); + + /** Returns the time in ms since the last call to reset or since + * the btClock was created. */ + public native @Cast("unsigned long long int") long getTimeMilliseconds(); + + /** Returns the time in us since the last call to reset or since + * the Clock was created. */ + public native @Cast("unsigned long long int") long getTimeMicroseconds(); + + public native @Cast("unsigned long long int") long getTimeNanoseconds(); + + /** Returns the time in s since the last call to reset or since + * the Clock was created. */ + public native @Cast("btScalar") float getTimeSeconds(); +} + +// #endif //USE_BT_CLOCK + +public static class btEnterProfileZoneFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btEnterProfileZoneFunc(Pointer p) { super(p); } + protected btEnterProfileZoneFunc() { allocate(); } + private native void allocate(); + public native void call(@Cast("const char*") BytePointer msg); +} +public static class btLeaveProfileZoneFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btLeaveProfileZoneFunc(Pointer p) { super(p); } + protected btLeaveProfileZoneFunc() { allocate(); } + private native void allocate(); + public native void call(); +} + +public static native btEnterProfileZoneFunc btGetCurrentEnterProfileZoneFunc(); +public static native btLeaveProfileZoneFunc btGetCurrentLeaveProfileZoneFunc(); + +public static native void btSetCustomEnterProfileZoneFunc(btEnterProfileZoneFunc enterFunc); +public static native void btSetCustomLeaveProfileZoneFunc(btLeaveProfileZoneFunc leaveFunc); + +// #ifndef BT_ENABLE_PROFILE +public static final int BT_NO_PROFILE = 1; +// #endif //BT_NO_PROFILE + +@MemberGetter public static native @Cast("const unsigned int") int BT_QUICKPROF_MAX_THREAD_COUNT(); + +//btQuickprofGetCurrentThreadIndex will return -1 if thread index cannot be determined, +//otherwise returns thread index in range [0..maxThreads] +public static native @Cast("unsigned int") int btQuickprofGetCurrentThreadIndex2(); + +// #ifndef BT_NO_PROFILE + +// #endif //#ifndef BT_NO_PROFILE + +/**ProfileSampleClass is a simple way to profile a function's scope + * Use the BT_PROFILE macro at the start of scope to time */ +public static class CProfileSample extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CProfileSample(Pointer p) { super(p); } + + public CProfileSample(@Cast("const char*") BytePointer name) { super((Pointer)null); allocate(name); } + private native void allocate(@Cast("const char*") BytePointer name); + public CProfileSample(String name) { super((Pointer)null); allocate(name); } + private native void allocate(String name); +} + +// #define BT_PROFILE(name) CProfileSample __profile(name) + +// #endif //BT_QUICK_PROF_H + + +// Parsed from LinearMath/btMotionState.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MOTIONSTATE_H +// #define BT_MOTIONSTATE_H + +// #include "btTransform.h" + +/**The btMotionState interface class allows the dynamics world to synchronize and interpolate the updated world transforms with graphics + * For optimizations, potentially only moving objects get synchronized (using setWorldPosition/setWorldOrientation) */ +public static class btMotionState extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMotionState(Pointer p) { super(p); } + + + public native void getWorldTransform(@ByRef btTransform worldTrans); + + //Bullet only calls the update of worldtransform for active objects + public native void setWorldTransform(@Const @ByRef btTransform worldTrans); +} + +// #endif //BT_MOTIONSTATE_H + + +// Parsed from LinearMath/btDefaultMotionState.h + +// #ifndef BT_DEFAULT_MOTION_STATE_H +// #define BT_DEFAULT_MOTION_STATE_H + +// #include "btMotionState.h" + +/**The btDefaultMotionState provides a common implementation to synchronize world transforms with offsets. */ +@NoOffset public static class btDefaultMotionState extends btMotionState { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultMotionState(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultMotionState(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultMotionState position(long position) { + return (btDefaultMotionState)super.position(position); + } + @Override public btDefaultMotionState getPointer(long i) { + return new btDefaultMotionState((Pointer)this).offsetAddress(i); + } + + public native @ByRef btTransform m_graphicsWorldTrans(); public native btDefaultMotionState m_graphicsWorldTrans(btTransform setter); + public native @ByRef btTransform m_centerOfMassOffset(); public native btDefaultMotionState m_centerOfMassOffset(btTransform setter); + public native @ByRef btTransform m_startWorldTrans(); public native btDefaultMotionState m_startWorldTrans(btTransform setter); + public native Pointer m_userPointer(); public native btDefaultMotionState m_userPointer(Pointer setter); + + public btDefaultMotionState(@Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform startTrans, @Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform centerOfMassOffset) { super((Pointer)null); allocate(startTrans, centerOfMassOffset); } + private native void allocate(@Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform startTrans, @Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform centerOfMassOffset); + public btDefaultMotionState() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**synchronizes world transform from user to physics */ + public native void getWorldTransform(@ByRef btTransform centerOfMassWorldTrans); + + /**synchronizes world transform from physics to user + * Bullet only calls the update of worldtransform for active objects */ + public native void setWorldTransform(@Const @ByRef btTransform centerOfMassWorldTrans); +} + +// #endif //BT_DEFAULT_MOTION_STATE_H + + +} diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java new file mode 100644 index 00000000000..4e116bea1b5 --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -0,0 +1,89 @@ +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +@Properties( + inherit = javacpp.class, + value = { + @Platform( + include = { + "LinearMath/btScalar.h", + "LinearMath/btVector3.h", + "LinearMath/btQuadWord.h", + "LinearMath/btQuaternion.h", + "LinearMath/btMatrix3x3.h", + "LinearMath/btTransform.h", + "LinearMath/btAlignedObjectArray.h", + "LinearMath/btHashMap.h", + "LinearMath/btSerializer.h", + "LinearMath/btIDebugDraw.h", + "LinearMath/btQuickprof.h", + "LinearMath/btMotionState.h", + "LinearMath/btDefaultMotionState.h", + }, + link = "LinearMath" + ) + }, + target = "org.bytedeco.bullet.LinearMath" +) +public class LinearMath implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + public void map(InfoMap infoMap) { + infoMap + // btScalar.h + .put(new Info("_WIN32").define(false)) + .put(new Info("defined(_MSC_VER)").define(false)) + .put(new Info("defined\t(__CELLOS_LV2__)").define(false)) + .put(new Info("USE_LIBSPE2").define(false)) + .put(new Info("(defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION)))").define(false)) + .put(new Info("defined(DEBUG) || defined (_DEBUG)").define(false)) + .put(new Info("defined(BT_USE_SSE) || defined(BT_USE_NEON)").define(false)) + .put(new Info("BT_USE_NEON").define(false)) + .put(new Info("defined(__SPU__) && defined(__CELLOS_LV2__)").define(false)) + .put(new Info("SIMD_FORCE_INLINE").cppTypes().annotations()) + .put(new Info("BT_INFINITY").skip()) + .put(new Info("BT_NAN").skip()) + .put(new Info("BT_USE_DOUBLE_PRECISION").define(false)) + .put(new Info("defined(BT_USE_DOUBLE_PRECISION)").define(false)) + .put(new Info("SIMD_EPSILON").skip()) + .put(new Info("SIMD_INFINITY").skip()) + .put(new Info("ATTRIBUTE_ALIGNED16").cppText("#define ATTRIBUTE_ALIGNED16(x) x")) + + // btVector3.h + .put(new Info("BT_DECLARE_ALIGNED_ALLOCATOR").skip()) + .put(new Info("(defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)").define(false)) + .put(new Info("btVector3Data").cppText("#define btVector3Data btVector3FloatData")) + .put(new Info("defined BT_USE_SSE").define(false)) + + // btQuaternion.h + .put(new Info("BT_USE_SSE").define(false)) + .put(new Info("defined(BT_USE_SSE)").define(false)) + .put(new Info("defined(BT_USE_NEON)").define(false)) + .put(new Info("btQuaternionData").cppText("#define btQuaternionData btQuaternionFloatData")) + + // btMatrix3x3.h + .put(new Info("btMatrix3x3Data").cppText("#define btMatrix3x3Data btMatrix3x3FloatData")) + + // btTransform.h + .put(new Info("btTransformData").cppText("#define btTransformData btTransformFloatData")) + + // btSerializer.h + .put(new Info("btBulletSerializedArrays").skip()) + .put(new Info("btHashMap").pointerTypes("btHashMap_btHashPtr_voidPointer")) + .put(new Info("btDefaultSerializer").immutable(true)) + .put(new Info("ENABLE_INMEMORY_SERIALIZER").define(false)) + + // btAlignedObjectArray.h + .put(new Info("btAlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector3")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btScalar")) + ; + } +} diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 500b5ef4c80..fa6f7245064 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -1,4 +1,5 @@ module org.bytedeco.bullet { requires transitive org.bytedeco.javacpp; exports org.bytedeco.bullet.presets; + exports org.bytedeco.bullet.LinearMath; } From a7ef1320026cf3cea5480ec793950f08cf2fd212 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Feb 2022 18:41:33 +0800 Subject: [PATCH 05/81] Generate bindings for bullet's BulletCollision library Part of the bullet's package. --- .../org/bytedeco/bullet/BulletCollision.java | 5615 +++++++++++++++++ .../bullet/presets/BulletCollision.java | 91 + bullet/src/main/java9/module-info.java | 1 + 3 files changed, 5707 insertions(+) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision.java create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision.java new file mode 100644 index 00000000000..2fef9bfa1d9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision.java @@ -0,0 +1,5615 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import static org.bytedeco.bullet.LinearMath.*; + +public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision { + static { Loader.load(); } + +// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseProxy.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BROADPHASE_PROXY_H +// #define BT_BROADPHASE_PROXY_H + +// #include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedAllocator.h" + +/** btDispatcher uses these types + * IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave + * to facilitate type checking + * CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code */ +/** enum BroadphaseNativeTypes */ +public static final int + // polyhedral convex shapes + BOX_SHAPE_PROXYTYPE = 0, + TRIANGLE_SHAPE_PROXYTYPE = 1, + TETRAHEDRAL_SHAPE_PROXYTYPE = 2, + CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE = 3, + CONVEX_HULL_SHAPE_PROXYTYPE = 4, + CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE = 5, + CUSTOM_POLYHEDRAL_SHAPE_TYPE = 6, + //implicit convex shapes + IMPLICIT_CONVEX_SHAPES_START_HERE = 7, + SPHERE_SHAPE_PROXYTYPE = 8, + MULTI_SPHERE_SHAPE_PROXYTYPE = 9, + CAPSULE_SHAPE_PROXYTYPE = 10, + CONE_SHAPE_PROXYTYPE = 11, + CONVEX_SHAPE_PROXYTYPE = 12, + CYLINDER_SHAPE_PROXYTYPE = 13, + UNIFORM_SCALING_SHAPE_PROXYTYPE = 14, + MINKOWSKI_SUM_SHAPE_PROXYTYPE = 15, + MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE = 16, + BOX_2D_SHAPE_PROXYTYPE = 17, + CONVEX_2D_SHAPE_PROXYTYPE = 18, + CUSTOM_CONVEX_SHAPE_TYPE = 19, + //concave shapes + CONCAVE_SHAPES_START_HERE = 20, + //keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy! + TRIANGLE_MESH_SHAPE_PROXYTYPE = 21, + SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE = 22, + /**used for demo integration FAST/Swift collision library and Bullet */ + FAST_CONCAVE_MESH_PROXYTYPE = 23, + //terrain + TERRAIN_SHAPE_PROXYTYPE = 24, + /**Used for GIMPACT Trimesh integration */ + GIMPACT_SHAPE_PROXYTYPE = 25, + /**Multimaterial mesh */ + MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE = 26, + + EMPTY_SHAPE_PROXYTYPE = 27, + STATIC_PLANE_PROXYTYPE = 28, + CUSTOM_CONCAVE_SHAPE_TYPE = 29, + SDF_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE, + CONCAVE_SHAPES_END_HERE = CUSTOM_CONCAVE_SHAPE_TYPE + 1, + + COMPOUND_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 2, + + SOFTBODY_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 3, + HFFLUID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 4, + HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 5, + INVALID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 6, + + MAX_BROADPHASE_COLLISION_TYPES = CUSTOM_CONCAVE_SHAPE_TYPE + 7; + +/**The btBroadphaseProxy is the main class that can be used with the Bullet broadphases. + * It stores collision shape type information, collision filter information and a client object, typically a btCollisionObject or btRigidBody. */ +@NoOffset public static class btBroadphaseProxy extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphaseProxy(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBroadphaseProxy(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBroadphaseProxy position(long position) { + return (btBroadphaseProxy)super.position(position); + } + @Override public btBroadphaseProxy getPointer(long i) { + return new btBroadphaseProxy((Pointer)this).offsetAddress(i); + } + + + /**optional filtering to cull potential collisions */ + /** enum btBroadphaseProxy::CollisionFilterGroups */ + public static final int + DefaultFilter = 1, + StaticFilter = 2, + KinematicFilter = 4, + DebrisFilter = 8, + SensorTrigger = 16, + CharacterFilter = 32, + AllFilter = -1; //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger + + //Usually the client btCollisionObject or Rigidbody class + public native Pointer m_clientObject(); public native btBroadphaseProxy m_clientObject(Pointer setter); + public native int m_collisionFilterGroup(); public native btBroadphaseProxy m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native btBroadphaseProxy m_collisionFilterMask(int setter); + + public native int m_uniqueId(); public native btBroadphaseProxy m_uniqueId(int setter); //m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. + + public native @ByRef btVector3 m_aabbMin(); public native btBroadphaseProxy m_aabbMin(btVector3 setter); + public native @ByRef btVector3 m_aabbMax(); public native btBroadphaseProxy m_aabbMax(btVector3 setter); + + public native int getUid(); + + //used for memory pools + public btBroadphaseProxy() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btBroadphaseProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask); } + private native void allocate(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); + + public static native @Cast("bool") boolean isPolyhedral(int proxyType); + + public static native @Cast("bool") boolean isConvex(int proxyType); + + public static native @Cast("bool") boolean isNonMoving(int proxyType); + + public static native @Cast("bool") boolean isConcave(int proxyType); + public static native @Cast("bool") boolean isCompound(int proxyType); + + public static native @Cast("bool") boolean isSoftBody(int proxyType); + + public static native @Cast("bool") boolean isInfinite(int proxyType); + + public static native @Cast("bool") boolean isConvex2d(int proxyType); +} + +@Opaque public static class btCollisionAlgorithm extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionAlgorithm() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionAlgorithm(Pointer p) { super(p); } +} + +/**The btBroadphasePair class contains a pair of aabb-overlapping objects. + * A btDispatcher can search a btCollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes. */ +@NoOffset public static class btBroadphasePair extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphasePair(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBroadphasePair(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBroadphasePair position(long position) { + return (btBroadphasePair)super.position(position); + } + @Override public btBroadphasePair getPointer(long i) { + return new btBroadphasePair((Pointer)this).offsetAddress(i); + } + + public btBroadphasePair() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btBroadphasePair(@ByRef btBroadphaseProxy proxy0, @ByRef btBroadphaseProxy proxy1) { super((Pointer)null); allocate(proxy0, proxy1); } + private native void allocate(@ByRef btBroadphaseProxy proxy0, @ByRef btBroadphaseProxy proxy1); + + public native btBroadphaseProxy m_pProxy0(); public native btBroadphasePair m_pProxy0(btBroadphaseProxy setter); + public native btBroadphaseProxy m_pProxy1(); public native btBroadphasePair m_pProxy1(btBroadphaseProxy setter); + + public native btCollisionAlgorithm m_algorithm(); public native btBroadphasePair m_algorithm(btCollisionAlgorithm setter); + public native Pointer m_internalInfo1(); public native btBroadphasePair m_internalInfo1(Pointer setter); + public native int m_internalTmpValue(); public native btBroadphasePair m_internalTmpValue(int setter); //don't use this data, it will be removed in future version. +} + +/* +//comparison for set operation, see Solid DT_Encounter +SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) +{ + return a.m_pProxy0 < b.m_pProxy0 || + (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); +} +*/ + +public static class btBroadphasePairSortPredicate extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btBroadphasePairSortPredicate() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBroadphasePairSortPredicate(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphasePairSortPredicate(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btBroadphasePairSortPredicate position(long position) { + return (btBroadphasePairSortPredicate)super.position(position); + } + @Override public btBroadphasePairSortPredicate getPointer(long i) { + return new btBroadphasePairSortPredicate((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") @Name("operator ()") boolean apply(@Const @ByRef btBroadphasePair a, @Const @ByRef btBroadphasePair b); +} + +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btBroadphasePair a, @Const @ByRef btBroadphasePair b); + +// #endif //BT_BROADPHASE_PROXY_H + + +// Parsed from BulletCollision/BroadphaseCollision/btDispatcher.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DISPATCHER_H +// #define BT_DISPATCHER_H +// #include "LinearMath/btScalar.h" +@Opaque public static class btRigidBody extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btRigidBody() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBody(Pointer p) { super(p); } +} +@Opaque public static class btCollisionObjectWrapper extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionObjectWrapper() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObjectWrapper(Pointer p) { super(p); } +} + +@Opaque public static class btPersistentManifold extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btPersistentManifold() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPersistentManifold(Pointer p) { super(p); } +} +@Opaque public static class btPoolAllocator extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btPoolAllocator() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoolAllocator(Pointer p) { super(p); } +} + +@NoOffset public static class btDispatcherInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDispatcherInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDispatcherInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDispatcherInfo position(long position) { + return (btDispatcherInfo)super.position(position); + } + @Override public btDispatcherInfo getPointer(long i) { + return new btDispatcherInfo((Pointer)this).offsetAddress(i); + } + + /** enum btDispatcherInfo::DispatchFunc */ + public static final int + DISPATCH_DISCRETE = 1, + DISPATCH_CONTINUOUS = 2; + public btDispatcherInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float m_timeStep(); public native btDispatcherInfo m_timeStep(float setter); + public native int m_stepCount(); public native btDispatcherInfo m_stepCount(int setter); + public native int m_dispatchFunc(); public native btDispatcherInfo m_dispatchFunc(int setter); + public native @Cast("btScalar") float m_timeOfImpact(); public native btDispatcherInfo m_timeOfImpact(float setter); + public native @Cast("bool") boolean m_useContinuous(); public native btDispatcherInfo m_useContinuous(boolean setter); + public native btIDebugDraw m_debugDraw(); public native btDispatcherInfo m_debugDraw(btIDebugDraw setter); + public native @Cast("bool") boolean m_enableSatConvex(); public native btDispatcherInfo m_enableSatConvex(boolean setter); + public native @Cast("bool") boolean m_enableSPU(); public native btDispatcherInfo m_enableSPU(boolean setter); + public native @Cast("bool") boolean m_useEpa(); public native btDispatcherInfo m_useEpa(boolean setter); + public native @Cast("btScalar") float m_allowedCcdPenetration(); public native btDispatcherInfo m_allowedCcdPenetration(float setter); + public native @Cast("bool") boolean m_useConvexConservativeDistanceUtil(); public native btDispatcherInfo m_useConvexConservativeDistanceUtil(boolean setter); + public native @Cast("btScalar") float m_convexConservativeDistanceThreshold(); public native btDispatcherInfo m_convexConservativeDistanceThreshold(float setter); + public native @Cast("bool") boolean m_deterministicOverlappingPairs(); public native btDispatcherInfo m_deterministicOverlappingPairs(boolean setter); +} + +/** enum ebtDispatcherQueryType */ +public static final int + BT_CONTACT_POINT_ALGORITHMS = 1, + BT_CLOSEST_POINT_ALGORITHMS = 2; + +/**The btDispatcher interface class can be used in combination with broadphase to dispatch calculations for overlapping pairs. + * For example for pairwise collision detection, calculating contact points stored in btPersistentManifold or user callbacks (game logic). */ +public static class btDispatcher extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDispatcher(Pointer p) { super(p); } + + + public native btCollisionAlgorithm findAlgorithm(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold, @Cast("ebtDispatcherQueryType") int queryType); + + public native btPersistentManifold getNewManifold(@Const btCollisionObject b0, @Const btCollisionObject b1); + + public native void releaseManifold(btPersistentManifold manifold); + + public native void clearManifold(btPersistentManifold manifold); + + public native @Cast("bool") boolean needsCollision(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native @Cast("bool") boolean needsResponse(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native void dispatchAllCollisionPairs(btOverlappingPairCache pairCache, @Const @ByRef btDispatcherInfo dispatchInfo, btDispatcher dispatcher); + + public native int getNumManifolds(); + + public native btPersistentManifold getManifoldByIndexInternal(int index); + + public native @Cast("btPersistentManifold**") PointerPointer getInternalManifoldPointer(); + + public native btPoolAllocator getInternalManifoldPool(); + + public native Pointer allocateCollisionAlgorithm(int size); + + public native void freeCollisionAlgorithm(Pointer ptr); +} + +// #endif //BT_DISPATCHER_H + + +// Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h + + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef OVERLAPPING_PAIR_CALLBACK_H +// #define OVERLAPPING_PAIR_CALLBACK_H + +/**The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache. */ +public static class btOverlappingPairCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOverlappingPairCallback(Pointer p) { super(p); } + + + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy0, btDispatcher dispatcher); +} + +// #endif //OVERLAPPING_PAIR_CALLBACK_H + + +// Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCache.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OVERLAPPING_PAIR_CACHE_H +// #define BT_OVERLAPPING_PAIR_CACHE_H + +// #include "btBroadphaseInterface.h" +// #include "btBroadphaseProxy.h" +// #include "btOverlappingPairCallback.h" + +// #include "LinearMath/btAlignedObjectArray.h" + +public static class btOverlapCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOverlapCallback(Pointer p) { super(p); } + + //return true for deletion of the pair + public native @Cast("bool") boolean processOverlap(@ByRef btBroadphasePair pair); +} + +public static class btOverlapFilterCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOverlapFilterCallback(Pointer p) { super(p); } + + // return true when pairs need collision + public native @Cast("bool") boolean needBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); +} + +@MemberGetter public static native int BT_NULL_PAIR(); + +/**The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases. + * The btHashedOverlappingPairCache and btSortedOverlappingPairCache classes are two implementations. */ +public static class btOverlappingPairCache extends btOverlappingPairCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOverlappingPairCache(Pointer p) { super(p); } + // this is needed so we can get to the derived class destructor + + public native btBroadphasePair getOverlappingPairArrayPtr(); + + + + public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); + + public native int getNumOverlappingPairs(); + public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + public native btOverlapFilterCallback getOverlapFilterCallback(); + public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native void setOverlapFilterCallback(btOverlapFilterCallback callback); + + public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); + + public native void processAllOverlappingPairs(btOverlapCallback callback, btDispatcher dispatcher, @Const @ByRef btDispatcherInfo arg2); + public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + public native void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback); + + public native void sortOverlappingPairs(btDispatcher dispatcher); +} + +/** Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com */ + +@NoOffset public static class btHashedOverlappingPairCache extends btOverlappingPairCache { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashedOverlappingPairCache(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHashedOverlappingPairCache(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btHashedOverlappingPairCache position(long position) { + return (btHashedOverlappingPairCache)super.position(position); + } + @Override public btHashedOverlappingPairCache getPointer(long i) { + return new btHashedOverlappingPairCache((Pointer)this).offsetAddress(i); + } + + + public btHashedOverlappingPairCache() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); + + public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + // Add a pair and return the new pair. If the pair already exists, + // no new pair is created and the old one is returned. + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); + + public native void processAllOverlappingPairs(btOverlapCallback callback, btDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); + + public native btBroadphasePair getOverlappingPairArrayPtr(); + + + + + + public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); + + public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native int GetCount(); + // btBroadphasePair* GetPairs() { return m_pairs; } + + public native btOverlapFilterCallback getOverlapFilterCallback(); + + public native void setOverlapFilterCallback(btOverlapFilterCallback callback); + + public native int getNumOverlappingPairs(); +} + +/**btSortedOverlappingPairCache maintains the objects with overlapping AABB + * Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase */ +@NoOffset public static class btSortedOverlappingPairCache extends btOverlappingPairCache { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSortedOverlappingPairCache(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSortedOverlappingPairCache(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSortedOverlappingPairCache position(long position) { + return (btSortedOverlappingPairCache)super.position(position); + } + @Override public btSortedOverlappingPairCache getPointer(long i) { + return new btSortedOverlappingPairCache((Pointer)this).offsetAddress(i); + } + + public btSortedOverlappingPairCache() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); + + public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); + + public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); + + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + + + + + public native btBroadphasePair getOverlappingPairArrayPtr(); + + public native int getNumOverlappingPairs(); + + public native btOverlapFilterCallback getOverlapFilterCallback(); + + public native void setOverlapFilterCallback(btOverlapFilterCallback callback); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + public native void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback); + + public native void sortOverlappingPairs(btDispatcher dispatcher); +} + +/**btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing. */ +@NoOffset public static class btNullPairCache extends btOverlappingPairCache { + static { Loader.load(); } + /** Default native constructor. */ + public btNullPairCache() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btNullPairCache(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btNullPairCache(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btNullPairCache position(long position) { + return (btNullPairCache)super.position(position); + } + @Override public btNullPairCache getPointer(long i) { + return new btNullPairCache((Pointer)this).offsetAddress(i); + } + + public native btBroadphasePair getOverlappingPairArrayPtr(); + + + public native void cleanOverlappingPair(@ByRef btBroadphasePair arg0, btDispatcher arg1); + + public native int getNumOverlappingPairs(); + + public native void cleanProxyFromPairs(btBroadphaseProxy arg0, btDispatcher arg1); + + public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy arg0, btBroadphaseProxy arg1); + public native btOverlapFilterCallback getOverlapFilterCallback(); + public native void setOverlapFilterCallback(btOverlapFilterCallback arg0); + + public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher arg1); + + public native btBroadphasePair findPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + public native void setInternalGhostPairCallback(btOverlappingPairCallback arg0); + + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1); + + public native Pointer removeOverlappingPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1, btDispatcher arg2); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy arg0, btDispatcher arg1); + + public native void sortOverlappingPairs(btDispatcher dispatcher); +} + +// #endif //BT_OVERLAPPING_PAIR_CACHE_H + + +// Parsed from BulletCollision/BroadphaseCollision/btQuantizedBvh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_QUANTIZED_BVH_H +// #define BT_QUANTIZED_BVH_H + +//#define DEBUG_CHECK_DEQUANTIZATION 1 +// #ifdef DEBUG_CHECK_DEQUANTIZATION +// #ifdef __SPU__ +// #endif //__SPU__ + +// #include +// #include +// #endif //DEBUG_CHECK_DEQUANTIZATION + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedAllocator.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btQuantizedBvhData btQuantizedBvhFloatData +// #define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData +public static final String btQuantizedBvhDataName = "btQuantizedBvhFloatData"; +// #endif + +//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp + +//Note: currently we have 16 bytes per quantized node +public static final int MAX_SUBTREE_SIZE_IN_BYTES = 2048; + +// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one +// actually) triangles each (since the sign bit is reserved +public static final int MAX_NUM_PARTS_IN_BITS = 10; + +/**btQuantizedBvhNode is a compressed aabb node, 16 bytes. + * Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range). */ +public static class btQuantizedBvhNode extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuantizedBvhNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuantizedBvhNode position(long position) { + return (btQuantizedBvhNode)super.position(position); + } + @Override public btQuantizedBvhNode getPointer(long i) { + return new btQuantizedBvhNode((Pointer)this).offsetAddress(i); + } + + + //12 bytes + public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native btQuantizedBvhNode m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native btQuantizedBvhNode m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); + //4 bytes + public native int m_escapeIndexOrTriangleIndex(); public native btQuantizedBvhNode m_escapeIndexOrTriangleIndex(int setter); + + public native @Cast("bool") boolean isLeafNode(); + public native int getEscapeIndex(); + public native int getTriangleIndex(); + public native int getPartId(); +} + +/** btOptimizedBvhNode contains both internal and leaf node information. + * Total node size is 44 bytes / node. You can use the compressed version of 16 bytes. */ +public static class btOptimizedBvhNode extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btOptimizedBvhNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btOptimizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOptimizedBvhNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btOptimizedBvhNode position(long position) { + return (btOptimizedBvhNode)super.position(position); + } + @Override public btOptimizedBvhNode getPointer(long i) { + return new btOptimizedBvhNode((Pointer)this).offsetAddress(i); + } + + + //32 bytes + public native @ByRef btVector3 m_aabbMinOrg(); public native btOptimizedBvhNode m_aabbMinOrg(btVector3 setter); + public native @ByRef btVector3 m_aabbMaxOrg(); public native btOptimizedBvhNode m_aabbMaxOrg(btVector3 setter); + + //4 + public native int m_escapeIndex(); public native btOptimizedBvhNode m_escapeIndex(int setter); + + //8 + //for child nodes + public native int m_subPart(); public native btOptimizedBvhNode m_subPart(int setter); + public native int m_triangleIndex(); public native btOptimizedBvhNode m_triangleIndex(int setter); + + //pad the size to 64 bytes + public native @Cast("char") byte m_padding(int i); public native btOptimizedBvhNode m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + +/**btBvhSubtreeInfo provides info to gather a subtree of limited size */ +@NoOffset public static class btBvhSubtreeInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBvhSubtreeInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBvhSubtreeInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBvhSubtreeInfo position(long position) { + return (btBvhSubtreeInfo)super.position(position); + } + @Override public btBvhSubtreeInfo getPointer(long i) { + return new btBvhSubtreeInfo((Pointer)this).offsetAddress(i); + } + + + //12 bytes + public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native btBvhSubtreeInfo m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native btBvhSubtreeInfo m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); + //4 bytes, points to the root of the subtree + public native int m_rootNodeIndex(); public native btBvhSubtreeInfo m_rootNodeIndex(int setter); + //4 bytes + public native int m_subtreeSize(); public native btBvhSubtreeInfo m_subtreeSize(int setter); + public native int m_padding(int i); public native btBvhSubtreeInfo m_padding(int i, int setter); + @MemberGetter public native IntPointer m_padding(); + + public btBvhSubtreeInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void setAabbFromQuantizeNode(@Const @ByRef btQuantizedBvhNode quantizedNode); +} + +public static class btNodeOverlapCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btNodeOverlapCallback(Pointer p) { super(p); } + + + public native void processNode(int subPart, int triangleIndex); +} + +// #include "LinearMath/btAlignedAllocator.h" +// #include "LinearMath/btAlignedObjectArray.h" + +/**for code readability: */ + +/**The btQuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU. + * It is used by the btBvhTriangleMeshShape as midphase. + * It is recommended to use quantization for better performance and lower memory requirements. */ +@NoOffset public static class btQuantizedBvh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btQuantizedBvh position(long position) { + return (btQuantizedBvh)super.position(position); + } + @Override public btQuantizedBvh getPointer(long i) { + return new btQuantizedBvh((Pointer)this).offsetAddress(i); + } + + /** enum btQuantizedBvh::btTraversalMode */ + public static final int + TRAVERSAL_STACKLESS = 0, + TRAVERSAL_STACKLESS_CACHE_FRIENDLY = 1, + TRAVERSAL_RECURSIVE = 2; + + public btQuantizedBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + + ///***************************************** expert/internal use only ************************* + public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("btScalar") float quantizationMargin/*=btScalar(1.0)*/); + public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); + public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btVector3 getLeafNodeArray(); + /**buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized */ + public native void buildInternal(); + ///***************************************** expert/internal use only ************************* + + public native void reportAabbOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + public native void reportRayOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget); + public native void reportBoxCastOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void quantize(@Cast("unsigned short*") ShortPointer out, @Const @ByRef btVector3 point, int isMax); + public native void quantize(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef btVector3 point, int isMax); + public native void quantize(@Cast("unsigned short*") short[] out, @Const @ByRef btVector3 point, int isMax); + + public native void quantizeWithClamp(@Cast("unsigned short*") ShortPointer out, @Const @ByRef btVector3 point2, int isMax); + public native void quantizeWithClamp(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef btVector3 point2, int isMax); + public native void quantizeWithClamp(@Cast("unsigned short*") short[] out, @Const @ByRef btVector3 point2, int isMax); + + public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") ShortPointer vecIn); + public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") ShortBuffer vecIn); + public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") short[] vecIn); + + /**setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees. */ + public native void setTraversalMode(@Cast("btQuantizedBvh::btTraversalMode") int traversalMode); + + public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btVector3 getQuantizedNodeArray(); + + public native @Cast("BvhSubtreeInfoArray*") @ByRef btAlignedObjectArray_btVector3 getSubtreeInfoArray(); + + //////////////////////////////////////////////////////////////////// + + /////Calculate space needed to store BVH for serialization + public native @Cast("unsigned") int calculateSerializeBufferSize(); + + /** Data buffer MUST be 16 byte aligned */ + public native @Cast("bool") boolean serialize(Pointer o_alignedDataBuffer, @Cast("unsigned") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + /**deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' */ + public static native btQuantizedBvh deSerializeInPlace(Pointer i_alignedDataBuffer, @Cast("unsigned int") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + public static native @Cast("unsigned int") int getAlignmentSerializationPadding(); + ////////////////////////////////////////////////////////////////////// + + public native int calculateSerializeBufferSizeNew(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void deSerializeFloat(@ByRef btQuantizedBvhFloatData quantizedBvhFloatData); + + public native void deSerializeDouble(@ByRef btQuantizedBvhDoubleData quantizedBvhDoubleData); + + //////////////////////////////////////////////////////////////////// + + public native @Cast("bool") boolean isQuantized(); +} + +// clang-format off +// parser needs * with the name +public static class btBvhSubtreeInfoData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btBvhSubtreeInfoData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBvhSubtreeInfoData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBvhSubtreeInfoData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btBvhSubtreeInfoData position(long position) { + return (btBvhSubtreeInfoData)super.position(position); + } + @Override public btBvhSubtreeInfoData getPointer(long i) { + return new btBvhSubtreeInfoData((Pointer)this).offsetAddress(i); + } + + public native int m_rootNodeIndex(); public native btBvhSubtreeInfoData m_rootNodeIndex(int setter); + public native int m_subtreeSize(); public native btBvhSubtreeInfoData m_subtreeSize(int setter); + public native @Cast("unsigned short") short m_quantizedAabbMin(int i); public native btBvhSubtreeInfoData m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short") short m_quantizedAabbMax(int i); public native btBvhSubtreeInfoData m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMax(); +} + +public static class btOptimizedBvhNodeFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btOptimizedBvhNodeFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btOptimizedBvhNodeFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOptimizedBvhNodeFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btOptimizedBvhNodeFloatData position(long position) { + return (btOptimizedBvhNodeFloatData)super.position(position); + } + @Override public btOptimizedBvhNodeFloatData getPointer(long i) { + return new btOptimizedBvhNodeFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_aabbMinOrg(); public native btOptimizedBvhNodeFloatData m_aabbMinOrg(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_aabbMaxOrg(); public native btOptimizedBvhNodeFloatData m_aabbMaxOrg(btVector3FloatData setter); + public native int m_escapeIndex(); public native btOptimizedBvhNodeFloatData m_escapeIndex(int setter); + public native int m_subPart(); public native btOptimizedBvhNodeFloatData m_subPart(int setter); + public native int m_triangleIndex(); public native btOptimizedBvhNodeFloatData m_triangleIndex(int setter); + public native @Cast("char") byte m_pad(int i); public native btOptimizedBvhNodeFloatData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} + +public static class btOptimizedBvhNodeDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btOptimizedBvhNodeDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btOptimizedBvhNodeDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOptimizedBvhNodeDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btOptimizedBvhNodeDoubleData position(long position) { + return (btOptimizedBvhNodeDoubleData)super.position(position); + } + @Override public btOptimizedBvhNodeDoubleData getPointer(long i) { + return new btOptimizedBvhNodeDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3DoubleData m_aabbMinOrg(); public native btOptimizedBvhNodeDoubleData m_aabbMinOrg(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_aabbMaxOrg(); public native btOptimizedBvhNodeDoubleData m_aabbMaxOrg(btVector3DoubleData setter); + public native int m_escapeIndex(); public native btOptimizedBvhNodeDoubleData m_escapeIndex(int setter); + public native int m_subPart(); public native btOptimizedBvhNodeDoubleData m_subPart(int setter); + public native int m_triangleIndex(); public native btOptimizedBvhNodeDoubleData m_triangleIndex(int setter); + public native @Cast("char") byte m_pad(int i); public native btOptimizedBvhNodeDoubleData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} + + +public static class btQuantizedBvhNodeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuantizedBvhNodeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhNodeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhNodeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuantizedBvhNodeData position(long position) { + return (btQuantizedBvhNodeData)super.position(position); + } + @Override public btQuantizedBvhNodeData getPointer(long i) { + return new btQuantizedBvhNodeData((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned short") short m_quantizedAabbMin(int i); public native btQuantizedBvhNodeData m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short") short m_quantizedAabbMax(int i); public native btQuantizedBvhNodeData m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMax(); + public native int m_escapeIndexOrTriangleIndex(); public native btQuantizedBvhNodeData m_escapeIndexOrTriangleIndex(int setter); +} + +public static class btQuantizedBvhFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuantizedBvhFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuantizedBvhFloatData position(long position) { + return (btQuantizedBvhFloatData)super.position(position); + } + @Override public btQuantizedBvhFloatData getPointer(long i) { + return new btQuantizedBvhFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_bvhAabbMin(); public native btQuantizedBvhFloatData m_bvhAabbMin(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_bvhAabbMax(); public native btQuantizedBvhFloatData m_bvhAabbMax(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_bvhQuantization(); public native btQuantizedBvhFloatData m_bvhQuantization(btVector3FloatData setter); + public native int m_curNodeIndex(); public native btQuantizedBvhFloatData m_curNodeIndex(int setter); + public native int m_useQuantization(); public native btQuantizedBvhFloatData m_useQuantization(int setter); + public native int m_numContiguousLeafNodes(); public native btQuantizedBvhFloatData m_numContiguousLeafNodes(int setter); + public native int m_numQuantizedContiguousNodes(); public native btQuantizedBvhFloatData m_numQuantizedContiguousNodes(int setter); + public native btOptimizedBvhNodeFloatData m_contiguousNodesPtr(); public native btQuantizedBvhFloatData m_contiguousNodesPtr(btOptimizedBvhNodeFloatData setter); + public native btQuantizedBvhNodeData m_quantizedContiguousNodesPtr(); public native btQuantizedBvhFloatData m_quantizedContiguousNodesPtr(btQuantizedBvhNodeData setter); + public native btBvhSubtreeInfoData m_subTreeInfoPtr(); public native btQuantizedBvhFloatData m_subTreeInfoPtr(btBvhSubtreeInfoData setter); + public native int m_traversalMode(); public native btQuantizedBvhFloatData m_traversalMode(int setter); + public native int m_numSubtreeHeaders(); public native btQuantizedBvhFloatData m_numSubtreeHeaders(int setter); + +} + +public static class btQuantizedBvhDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuantizedBvhDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuantizedBvhDoubleData position(long position) { + return (btQuantizedBvhDoubleData)super.position(position); + } + @Override public btQuantizedBvhDoubleData getPointer(long i) { + return new btQuantizedBvhDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3DoubleData m_bvhAabbMin(); public native btQuantizedBvhDoubleData m_bvhAabbMin(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_bvhAabbMax(); public native btQuantizedBvhDoubleData m_bvhAabbMax(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_bvhQuantization(); public native btQuantizedBvhDoubleData m_bvhQuantization(btVector3DoubleData setter); + public native int m_curNodeIndex(); public native btQuantizedBvhDoubleData m_curNodeIndex(int setter); + public native int m_useQuantization(); public native btQuantizedBvhDoubleData m_useQuantization(int setter); + public native int m_numContiguousLeafNodes(); public native btQuantizedBvhDoubleData m_numContiguousLeafNodes(int setter); + public native int m_numQuantizedContiguousNodes(); public native btQuantizedBvhDoubleData m_numQuantizedContiguousNodes(int setter); + public native btOptimizedBvhNodeDoubleData m_contiguousNodesPtr(); public native btQuantizedBvhDoubleData m_contiguousNodesPtr(btOptimizedBvhNodeDoubleData setter); + public native btQuantizedBvhNodeData m_quantizedContiguousNodesPtr(); public native btQuantizedBvhDoubleData m_quantizedContiguousNodesPtr(btQuantizedBvhNodeData setter); + + public native int m_traversalMode(); public native btQuantizedBvhDoubleData m_traversalMode(int setter); + public native int m_numSubtreeHeaders(); public native btQuantizedBvhDoubleData m_numSubtreeHeaders(int setter); + public native btBvhSubtreeInfoData m_subTreeInfoPtr(); public native btQuantizedBvhDoubleData m_subTreeInfoPtr(btBvhSubtreeInfoData setter); +} +// clang-format on + + + +// #endif //BT_QUANTIZED_BVH_H + + +// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BROADPHASE_INTERFACE_H +// #define BT_BROADPHASE_INTERFACE_H +// #include "btBroadphaseProxy.h" + +public static class btBroadphaseAabbCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphaseAabbCallback(Pointer p) { super(p); } + + public native @Cast("bool") boolean process(@Const btBroadphaseProxy proxy); +} + +@NoOffset public static class btBroadphaseRayCallback extends btBroadphaseAabbCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphaseRayCallback(Pointer p) { super(p); } + + /**added some cached data to accelerate ray-AABB tests */ + public native @ByRef btVector3 m_rayDirectionInverse(); public native btBroadphaseRayCallback m_rayDirectionInverse(btVector3 setter); + public native @Cast("unsigned int") int m_signs(int i); public native btBroadphaseRayCallback m_signs(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer m_signs(); + public native @Cast("btScalar") float m_lambda_max(); public native btBroadphaseRayCallback m_lambda_max(float setter); +} + +// #include "LinearMath/btVector3.h" + +/**The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs. + * Some implementations for this broadphase interface include btAxisSweep3, bt32BitAxisSweep3 and btDbvtBroadphase. + * The actual overlapping pair management, storage, adding and removing of pairs is dealt by the btOverlappingPairCache class. */ +public static class btBroadphaseInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphaseInterface(Pointer p) { super(p); } + + + public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); + public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); + public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); + + public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); + + /**calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb */ + public native void calculateOverlappingPairs(btDispatcher dispatcher); + + public native btOverlappingPairCache getOverlappingPairCache(); + + /**getAabb returns the axis aligned bounding box in the 'global' coordinate frame + * will add some transform later */ + public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /**reset broadphase internal structures, to ensure determinism/reproducability */ + public native void resetPool(btDispatcher dispatcher); + + public native void printStats(); +} + +// #endif //BT_BROADPHASE_INTERFACE_H + + +// Parsed from BulletCollision/BroadphaseCollision/btSimpleBroadphase.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMPLE_BROADPHASE_H +// #define BT_SIMPLE_BROADPHASE_H + +// #include "btOverlappingPairCache.h" + +@NoOffset public static class btSimpleBroadphaseProxy extends btBroadphaseProxy { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimpleBroadphaseProxy(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSimpleBroadphaseProxy(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSimpleBroadphaseProxy position(long position) { + return (btSimpleBroadphaseProxy)super.position(position); + } + @Override public btSimpleBroadphaseProxy getPointer(long i) { + return new btSimpleBroadphaseProxy((Pointer)this).offsetAddress(i); + } + + public native int m_nextFree(); public native btSimpleBroadphaseProxy m_nextFree(int setter); + + // int m_handleId; + + public btSimpleBroadphaseProxy() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btSimpleBroadphaseProxy(@Const @ByRef btVector3 minpt, @Const @ByRef btVector3 maxpt, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(minpt, maxpt, shapeType, userPtr, collisionFilterGroup, collisionFilterMask); } + private native void allocate(@Const @ByRef btVector3 minpt, @Const @ByRef btVector3 maxpt, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); + + public native void SetNextFree(int next); + public native int GetNextFree(); +} + +/**The SimpleBroadphase is just a unit-test for btAxisSweep3, bt32BitAxisSweep3, or btDbvtBroadphase, so use those classes instead. + * It is a brute force aabb culling broadphase based on O(n^2) aabb checks */ +@NoOffset public static class btSimpleBroadphase extends btBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimpleBroadphase(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSimpleBroadphase(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSimpleBroadphase position(long position) { + return (btSimpleBroadphase)super.position(position); + } + @Override public btSimpleBroadphase getPointer(long i) { + return new btSimpleBroadphase((Pointer)this).offsetAddress(i); + } + + public btSimpleBroadphase(int maxProxies/*=16384*/, btOverlappingPairCache overlappingPairCache/*=0*/) { super((Pointer)null); allocate(maxProxies, overlappingPairCache); } + private native void allocate(int maxProxies/*=16384*/, btOverlappingPairCache overlappingPairCache/*=0*/); + public btSimpleBroadphase() { super((Pointer)null); allocate(); } + private native void allocate(); + + public static native @Cast("bool") boolean aabbOverlap(btSimpleBroadphaseProxy proxy0, btSimpleBroadphaseProxy proxy1); + + public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); + + public native void calculateOverlappingPairs(btDispatcher dispatcher); + + public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); + public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); + public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); + + public native btOverlappingPairCache getOverlappingPairCache(); + + public native @Cast("bool") boolean testAabbOverlap(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + /**getAabb returns the axis aligned bounding box in the 'global' coordinate frame + * will add some transform later */ + public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void printStats(); +} + +// #endif //BT_SIMPLE_BROADPHASE_H + + +// Parsed from BulletCollision/BroadphaseCollision/btAxisSweep3.h + +//Bullet Continuous Collision Detection and Physics Library +//Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +// +// btAxisSweep3.h +// +// Copyright (c) 2006 Simon Hobbs +// +// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. + +// #ifndef BT_AXIS_SWEEP_3_H +// #define BT_AXIS_SWEEP_3_H + +// #include "LinearMath/btVector3.h" +// #include "btOverlappingPairCache.h" +// #include "btBroadphaseInterface.h" +// #include "btBroadphaseProxy.h" +// #include "btOverlappingPairCallback.h" +// #include "btDbvtBroadphase.h" +// #include "btAxisSweep3Internal.h" + +/** The btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase. + * It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit integer coordinates instead of floats. + * For large worlds and many objects, use bt32BitAxisSweep3 or btDbvtBroadphase instead. bt32BitAxisSweep3 has higher precision and allows more then 16384 objects at the cost of more memory and bit of performance. */ +public static class btAxisSweep3 extends btBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAxisSweep3(Pointer p) { super(p); } + + public btAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned short int") short maxHandles/*=16384*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax, maxHandles, pairCache, disableRaycastAccelerator); } + private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned short int") short maxHandles/*=16384*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/); + public btAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax); } + private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax); +} + +/** The bt32BitAxisSweep3 allows higher precision quantization and more objects compared to the btAxisSweep3 sweep and prune. + * This comes at the cost of more memory per handle, and a bit slower performance. + * It uses arrays rather then lists for storage of the 3 axis. */ +public static class bt32BitAxisSweep3 extends btBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public bt32BitAxisSweep3(Pointer p) { super(p); } + + public bt32BitAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned int") int maxHandles/*=1500000*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax, maxHandles, pairCache, disableRaycastAccelerator); } + private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned int") int maxHandles/*=1500000*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/); + public bt32BitAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax); } + private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax); +} + +// #endif + + +// Parsed from BulletCollision/BroadphaseCollision/btDbvtBroadphase.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**btDbvtBroadphase implementation by Nathanael Presson */ +// #ifndef BT_DBVT_BROADPHASE_H +// #define BT_DBVT_BROADPHASE_H + +// #include "BulletCollision/BroadphaseCollision/btDbvt.h" +// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" + +// +// Compile time config +// + +public static native @MemberGetter int DBVT_BP_PROFILE(); +public static final int DBVT_BP_PROFILE = DBVT_BP_PROFILE(); +//#define DBVT_BP_SORTPAIRS 1 +public static final int DBVT_BP_PREVENTFALSEUPDATE = 0; +public static final int DBVT_BP_ACCURATESLEEPING = 0; +public static final int DBVT_BP_ENABLE_BENCHMARK = 0; +//#define DBVT_BP_MARGIN (btScalar)0.05 +public static native @Cast("btScalar") float gDbvtMargin(); public static native void gDbvtMargin(float setter); + +// #if DBVT_BP_PROFILE +// #endif + +// +// btDbvtProxy +// + +/**The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt). + * One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other. + * This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases btAxisSweep3 and bt32BitAxisSweep3. */ +@NoOffset public static class btDbvtBroadphase extends btBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvtBroadphase(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDbvtBroadphase(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDbvtBroadphase position(long position) { + return (btDbvtBroadphase)super.position(position); + } + @Override public btDbvtBroadphase getPointer(long i) { + return new btDbvtBroadphase((Pointer)this).offsetAddress(i); + } + + /* Config */ + /** enum btDbvtBroadphase:: */ + public static final int + DYNAMIC_SET = 0, /* Dynamic set index */ + FIXED_SET = 1, /* Fixed set index */ + STAGECOUNT = 2; /* Number of stages */ + /* Fields */ + public native @ByRef btDbvt m_sets(int i); public native btDbvtBroadphase m_sets(int i, btDbvt setter); + @MemberGetter public native btDbvt m_sets(); // Dbvt sets // Stages list + public native btOverlappingPairCache m_paircache(); public native btDbvtBroadphase m_paircache(btOverlappingPairCache setter); // Pair cache + public native @Cast("btScalar") float m_prediction(); public native btDbvtBroadphase m_prediction(float setter); // Velocity prediction + public native int m_stageCurrent(); public native btDbvtBroadphase m_stageCurrent(int setter); // Current stage + public native int m_fupdates(); public native btDbvtBroadphase m_fupdates(int setter); // % of fixed updates per frame + public native int m_dupdates(); public native btDbvtBroadphase m_dupdates(int setter); // % of dynamic updates per frame + public native int m_cupdates(); public native btDbvtBroadphase m_cupdates(int setter); // % of cleanup updates per frame + public native int m_newpairs(); public native btDbvtBroadphase m_newpairs(int setter); // Number of pairs created + public native int m_fixedleft(); public native btDbvtBroadphase m_fixedleft(int setter); // Fixed optimization left + public native @Cast("unsigned") int m_updates_call(); public native btDbvtBroadphase m_updates_call(int setter); // Number of updates call + public native @Cast("unsigned") int m_updates_done(); public native btDbvtBroadphase m_updates_done(int setter); // Number of updates done + public native @Cast("btScalar") float m_updates_ratio(); public native btDbvtBroadphase m_updates_ratio(float setter); // m_updates_done/m_updates_call + public native int m_pid(); public native btDbvtBroadphase m_pid(int setter); // Parse id + public native int m_cid(); public native btDbvtBroadphase m_cid(int setter); // Cleanup index + public native int m_gid(); public native btDbvtBroadphase m_gid(int setter); // Gen id + public native @Cast("bool") boolean m_releasepaircache(); public native btDbvtBroadphase m_releasepaircache(boolean setter); // Release pair cache on delete + public native @Cast("bool") boolean m_deferedcollide(); public native btDbvtBroadphase m_deferedcollide(boolean setter); // Defere dynamic/static collision to collide call + public native @Cast("bool") boolean m_needcleanup(); public native btDbvtBroadphase m_needcleanup(boolean setter); // Need to run cleanup? + +// #if DBVT_BP_PROFILE +// #endif + /* Methods */ + public btDbvtBroadphase(btOverlappingPairCache paircache/*=0*/) { super((Pointer)null); allocate(paircache); } + private native void allocate(btOverlappingPairCache paircache/*=0*/); + public btDbvtBroadphase() { super((Pointer)null); allocate(); } + private native void allocate(); + public native void collide(btDispatcher dispatcher); + public native void optimize(); + + /* btBroadphaseInterface Implementation */ + public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); + public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); + public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); + + public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + public native void calculateOverlappingPairs(btDispatcher dispatcher); + public native btOverlappingPairCache getOverlappingPairCache(); + public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + public native void printStats(); + + /**reset broadphase internal structures, to ensure determinism/reproducability */ + public native void resetPool(btDispatcher dispatcher); + + public native void performDeferredRemoval(btDispatcher dispatcher); + + public native void setVelocityPrediction(@Cast("btScalar") float prediction); + public native @Cast("btScalar") float getVelocityPrediction(); + + /**this setAabbForceUpdate is similar to setAabb but always forces the aabb update. + * it is not part of the btBroadphaseInterface but specific to btDbvtBroadphase. + * it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see + * http://code.google.com/p/bullet/issues/detail?id=223 */ + public native void setAabbForceUpdate(btBroadphaseProxy absproxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher arg3); + + public static native void benchmark(btBroadphaseInterface arg0); +} + +// #endif + + +// Parsed from BulletCollision/NarrowPhaseCollision/btManifoldPoint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MANIFOLD_CONTACT_POINT_H +// #define BT_MANIFOLD_CONTACT_POINT_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransformUtil.h" + +// #ifdef PFX_USE_FREE_VECTORMATH +// #else +// Don't change following order of parameters +public static class btConstraintRow extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConstraintRow() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConstraintRow(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintRow(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConstraintRow position(long position) { + return (btConstraintRow)super.position(position); + } + @Override public btConstraintRow getPointer(long i) { + return new btConstraintRow((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_normal(int i); public native btConstraintRow m_normal(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_normal(); + public native @Cast("btScalar") float m_rhs(); public native btConstraintRow m_rhs(float setter); + public native @Cast("btScalar") float m_jacDiagInv(); public native btConstraintRow m_jacDiagInv(float setter); + public native @Cast("btScalar") float m_lowerLimit(); public native btConstraintRow m_lowerLimit(float setter); + public native @Cast("btScalar") float m_upperLimit(); public native btConstraintRow m_upperLimit(float setter); + public native @Cast("btScalar") float m_accumImpulse(); public native btConstraintRow m_accumImpulse(float setter); +} +// #endif //PFX_USE_FREE_VECTORMATH + +/** enum btContactPointFlags */ +public static final int + BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED = 1, + BT_CONTACT_FLAG_HAS_CONTACT_CFM = 2, + BT_CONTACT_FLAG_HAS_CONTACT_ERP = 4, + BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING = 8, + BT_CONTACT_FLAG_FRICTION_ANCHOR = 16; + +/** ManifoldContactPoint collects and maintains persistent contactpoints. + * used to improve stability and performance of rigidbody dynamics response. */ +@NoOffset public static class btManifoldPoint extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btManifoldPoint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btManifoldPoint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btManifoldPoint position(long position) { + return (btManifoldPoint)super.position(position); + } + @Override public btManifoldPoint getPointer(long i) { + return new btManifoldPoint((Pointer)this).offsetAddress(i); + } + + public btManifoldPoint() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btManifoldPoint(@Const @ByRef btVector3 pointA, @Const @ByRef btVector3 pointB, + @Const @ByRef btVector3 normal, + @Cast("btScalar") float distance) { super((Pointer)null); allocate(pointA, pointB, normal, distance); } + private native void allocate(@Const @ByRef btVector3 pointA, @Const @ByRef btVector3 pointB, + @Const @ByRef btVector3 normal, + @Cast("btScalar") float distance); + + public native @ByRef btVector3 m_localPointA(); public native btManifoldPoint m_localPointA(btVector3 setter); + public native @ByRef btVector3 m_localPointB(); public native btManifoldPoint m_localPointB(btVector3 setter); + public native @ByRef btVector3 m_positionWorldOnB(); public native btManifoldPoint m_positionWorldOnB(btVector3 setter); + /**m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity */ + public native @ByRef btVector3 m_positionWorldOnA(); public native btManifoldPoint m_positionWorldOnA(btVector3 setter); + public native @ByRef btVector3 m_normalWorldOnB(); public native btManifoldPoint m_normalWorldOnB(btVector3 setter); + + public native @Cast("btScalar") float m_distance1(); public native btManifoldPoint m_distance1(float setter); + public native @Cast("btScalar") float m_combinedFriction(); public native btManifoldPoint m_combinedFriction(float setter); + public native @Cast("btScalar") float m_combinedRollingFriction(); public native btManifoldPoint m_combinedRollingFriction(float setter); //torsional friction orthogonal to contact normal, useful to make spheres stop rolling forever + public native @Cast("btScalar") float m_combinedSpinningFriction(); public native btManifoldPoint m_combinedSpinningFriction(float setter); //torsional friction around contact normal, useful for grasping objects + public native @Cast("btScalar") float m_combinedRestitution(); public native btManifoldPoint m_combinedRestitution(float setter); + + //BP mod, store contact triangles. + public native int m_partId0(); public native btManifoldPoint m_partId0(int setter); + public native int m_partId1(); public native btManifoldPoint m_partId1(int setter); + public native int m_index0(); public native btManifoldPoint m_index0(int setter); + public native int m_index1(); public native btManifoldPoint m_index1(int setter); + + public native Pointer m_userPersistentData(); public native btManifoldPoint m_userPersistentData(Pointer setter); + //bool m_lateralFrictionInitialized; + public native int m_contactPointFlags(); public native btManifoldPoint m_contactPointFlags(int setter); + + public native @Cast("btScalar") float m_appliedImpulse(); public native btManifoldPoint m_appliedImpulse(float setter); + public native @Cast("btScalar") float m_prevRHS(); public native btManifoldPoint m_prevRHS(float setter); + public native @Cast("btScalar") float m_appliedImpulseLateral1(); public native btManifoldPoint m_appliedImpulseLateral1(float setter); + public native @Cast("btScalar") float m_appliedImpulseLateral2(); public native btManifoldPoint m_appliedImpulseLateral2(float setter); + public native @Cast("btScalar") float m_contactMotion1(); public native btManifoldPoint m_contactMotion1(float setter); + public native @Cast("btScalar") float m_contactMotion2(); public native btManifoldPoint m_contactMotion2(float setter); + public native @Cast("btScalar") float m_contactCFM(); public native btManifoldPoint m_contactCFM(float setter); + public native @Cast("btScalar") float m_combinedContactStiffness1(); public native btManifoldPoint m_combinedContactStiffness1(float setter); + public native @Cast("btScalar") float m_contactERP(); public native btManifoldPoint m_contactERP(float setter); + public native @Cast("btScalar") float m_combinedContactDamping1(); public native btManifoldPoint m_combinedContactDamping1(float setter); + + public native @Cast("btScalar") float m_frictionCFM(); public native btManifoldPoint m_frictionCFM(float setter); + + public native int m_lifeTime(); public native btManifoldPoint m_lifeTime(int setter); //lifetime of the contactpoint in frames + + public native @ByRef btVector3 m_lateralFrictionDir1(); public native btManifoldPoint m_lateralFrictionDir1(btVector3 setter); + public native @ByRef btVector3 m_lateralFrictionDir2(); public native btManifoldPoint m_lateralFrictionDir2(btVector3 setter); + + public native @Cast("btScalar") float getDistance(); + public native int getLifeTime(); + + public native @Const @ByRef btVector3 getPositionWorldOnA(); + + public native @Const @ByRef btVector3 getPositionWorldOnB(); + + public native void setDistance(@Cast("btScalar") float dist); + + /**this returns the most recent applied impulse, to satisfy contact constraints by the constraint solver */ + public native @Cast("btScalar") float getAppliedImpulse(); +} + +// #endif //BT_MANIFOLD_CONTACT_POINT_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H +// #define BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btVector3.h" + +/** This interface is made to be used by an iterative approach to do TimeOfImpact calculations + * This interface allows to query for closest points and penetration depth between two (convex) objects + * the closest point is on the second object (B), and the normal points from the surface on B towards A. + * distance is between closest points on B and closest point on A. So you can calculate closest point on A + * by taking closestPointInA = closestPointInB + m_distance * m_normalOnSurfaceB */ +public static class btDiscreteCollisionDetectorInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDiscreteCollisionDetectorInterface(Pointer p) { super(p); } + + public static class Result extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Result(Pointer p) { super(p); } + + + /**setShapeIdentifiersA/B provides experimental support for per-triangle material / custom material combiner */ + public native void setShapeIdentifiersA(int partId0, int index0); + public native void setShapeIdentifiersB(int partId1, int index1); + public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); + } + + @NoOffset public static class ClosestPointInput extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ClosestPointInput(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public ClosestPointInput(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public ClosestPointInput position(long position) { + return (ClosestPointInput)super.position(position); + } + @Override public ClosestPointInput getPointer(long i) { + return new ClosestPointInput((Pointer)this).offsetAddress(i); + } + + public ClosestPointInput() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @ByRef btTransform m_transformA(); public native ClosestPointInput m_transformA(btTransform setter); + public native @ByRef btTransform m_transformB(); public native ClosestPointInput m_transformB(btTransform setter); + public native @Cast("btScalar") float m_maximumDistanceSquared(); public native ClosestPointInput m_maximumDistanceSquared(float setter); + } + + // + // give either closest points (distance > 0) or penetration (distance) + // the normal always points from B towards A + // + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw, @Cast("bool") boolean swapResults/*=false*/); + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw); +} + +@NoOffset public static class btStorageResult extends btDiscreteCollisionDetectorInterface.Result { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStorageResult(Pointer p) { super(p); } + + public native @ByRef btVector3 m_normalOnSurfaceB(); public native btStorageResult m_normalOnSurfaceB(btVector3 setter); + public native @ByRef btVector3 m_closestPointInB(); public native btStorageResult m_closestPointInB(btVector3 setter); + public native @Cast("btScalar") float m_distance(); public native btStorageResult m_distance(float setter); + + public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); +} + +// #endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionObject.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_OBJECT_H +// #define BT_COLLISION_OBJECT_H + +// #include "LinearMath/btTransform.h" + +//island management, m_activationState1 +public static final int ACTIVE_TAG = 1; +public static final int ISLAND_SLEEPING = 2; +public static final int WANTS_DEACTIVATION = 3; +public static final int DISABLE_DEACTIVATION = 4; +public static final int DISABLE_SIMULATION = 5; +public static final int FIXED_BASE_MULTI_BODY = 6; +// #include "LinearMath/btMotionState.h" +// #include "LinearMath/btAlignedAllocator.h" +// #include "LinearMath/btAlignedObjectArray.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btCollisionObjectData btCollisionObjectFloatData +public static final String btCollisionObjectDataName = "btCollisionObjectFloatData"; +// #endif + +/** btCollisionObject can be used to manage collision detection objects. + * btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy. + * They can be added to the btCollisionWorld. */ +@NoOffset public static class btCollisionObject extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObject(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionObject(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCollisionObject position(long position) { + return (btCollisionObject)super.position(position); + } + @Override public btCollisionObject getPointer(long i) { + return new btCollisionObject((Pointer)this).offsetAddress(i); + } + + + /** enum btCollisionObject::CollisionFlags */ + public static final int + CF_DYNAMIC_OBJECT = 0, + CF_STATIC_OBJECT = 1, + CF_KINEMATIC_OBJECT = 2, + CF_NO_CONTACT_RESPONSE = 4, + CF_CUSTOM_MATERIAL_CALLBACK = 8, //this allows per-triangle material (friction/restitution) + CF_CHARACTER_OBJECT = 16, + CF_DISABLE_VISUALIZE_OBJECT = 32, //disable debug drawing + CF_DISABLE_SPU_COLLISION_PROCESSING = 64, //disable parallel/SPU processing + CF_HAS_CONTACT_STIFFNESS_DAMPING = 128, + CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256, + CF_HAS_FRICTION_ANCHOR = 512, + CF_HAS_COLLISION_SOUND_TRIGGER = 1024; + + /** enum btCollisionObject::CollisionObjectTypes */ + public static final int + CO_COLLISION_OBJECT = 1, + CO_RIGID_BODY = 2, + /**CO_GHOST_OBJECT keeps track of all objects overlapping its AABB and that pass its collision filter + * It is useful for collision sensors, explosion objects, character controller etc. */ + CO_GHOST_OBJECT = 4, + CO_SOFT_BODY = 8, + CO_HF_FLUID = 16, + CO_USER_TYPE = 32, + CO_FEATHERSTONE_LINK = 64; + + /** enum btCollisionObject::AnisotropicFrictionFlags */ + public static final int + CF_ANISOTROPIC_FRICTION_DISABLED = 0, + CF_ANISOTROPIC_FRICTION = 1, + CF_ANISOTROPIC_ROLLING_FRICTION = 2; + + public native @Cast("bool") boolean mergesSimulationIslands(); + + public native @Const @ByRef btVector3 getAnisotropicFriction(); + public native void setAnisotropicFriction(@Const @ByRef btVector3 anisotropicFriction, int frictionMode/*=btCollisionObject::CF_ANISOTROPIC_FRICTION*/); + public native void setAnisotropicFriction(@Const @ByRef btVector3 anisotropicFriction); + public native @Cast("bool") boolean hasAnisotropicFriction(int frictionMode/*=btCollisionObject::CF_ANISOTROPIC_FRICTION*/); + public native @Cast("bool") boolean hasAnisotropicFriction(); + + /**the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default. + * Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges */ + public native void setContactProcessingThreshold(@Cast("btScalar") float contactProcessingThreshold); + public native @Cast("btScalar") float getContactProcessingThreshold(); + + public native @Cast("bool") boolean isStaticObject(); + + public native @Cast("bool") boolean isKinematicObject(); + + public native @Cast("bool") boolean isStaticOrKinematicObject(); + + public native @Cast("bool") boolean hasContactResponse(); + + public btCollisionObject() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void setCollisionShape(btCollisionShape collisionShape); + + public native btCollisionShape getCollisionShape(); + + public native void setIgnoreCollisionCheck(@Const btCollisionObject co, @Cast("bool") boolean ignoreCollisionCheck); + + public native int getNumObjectsWithoutCollision(); + + public native @Const btCollisionObject getObjectWithoutCollision(int index); + + public native @Cast("bool") boolean checkCollideWithOverride(@Const btCollisionObject co); + + /**Avoid using this internal API call, the extension pointer is used by some Bullet extensions. + * If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead. */ + public native Pointer internalGetExtensionPointer(); + /**Avoid using this internal API call, the extension pointer is used by some Bullet extensions + * If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead. */ + public native void internalSetExtensionPointer(Pointer pointer); + + public native int getActivationState(); + + public native void setActivationState(int newState); + + public native void setDeactivationTime(@Cast("btScalar") float time); + public native @Cast("btScalar") float getDeactivationTime(); + + public native void forceActivationState(int newState); + + public native void activate(@Cast("bool") boolean forceActivation/*=false*/); + public native void activate(); + + public native @Cast("bool") boolean isActive(); + + public native void setRestitution(@Cast("btScalar") float rest); + public native @Cast("btScalar") float getRestitution(); + public native void setFriction(@Cast("btScalar") float frict); + public native @Cast("btScalar") float getFriction(); + + public native void setRollingFriction(@Cast("btScalar") float frict); + public native @Cast("btScalar") float getRollingFriction(); + public native void setSpinningFriction(@Cast("btScalar") float frict); + public native @Cast("btScalar") float getSpinningFriction(); + public native void setContactStiffnessAndDamping(@Cast("btScalar") float stiffness, @Cast("btScalar") float damping); + + public native @Cast("btScalar") float getContactStiffness(); + + public native @Cast("btScalar") float getContactDamping(); + + /**reserved for Bullet internal usage */ + public native int getInternalType(); + + public native @ByRef btTransform getWorldTransform(); + + public native void setWorldTransform(@Const @ByRef btTransform worldTrans); + + public native btBroadphaseProxy getBroadphaseHandle(); + + public native void setBroadphaseHandle(btBroadphaseProxy handle); + + public native @ByRef btTransform getInterpolationWorldTransform(); + + public native void setInterpolationWorldTransform(@Const @ByRef btTransform trans); + + public native void setInterpolationLinearVelocity(@Const @ByRef btVector3 linvel); + + public native void setInterpolationAngularVelocity(@Const @ByRef btVector3 angvel); + + public native @Const @ByRef btVector3 getInterpolationLinearVelocity(); + + public native @Const @ByRef btVector3 getInterpolationAngularVelocity(); + + public native int getIslandTag(); + + public native void setIslandTag(int tag); + + public native int getCompanionId(); + + public native void setCompanionId(int id); + + public native int getWorldArrayIndex(); + + // only should be called by CollisionWorld + public native void setWorldArrayIndex(int ix); + + public native @Cast("btScalar") float getHitFraction(); + + public native void setHitFraction(@Cast("btScalar") float hitFraction); + + public native int getCollisionFlags(); + + public native void setCollisionFlags(int flags); + + /**Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: */ + public native @Cast("btScalar") float getCcdSweptSphereRadius(); + + /**Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: */ + public native void setCcdSweptSphereRadius(@Cast("btScalar") float radius); + + public native @Cast("btScalar") float getCcdMotionThreshold(); + + public native @Cast("btScalar") float getCcdSquareMotionThreshold(); + + /** Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold */ + public native void setCcdMotionThreshold(@Cast("btScalar") float ccdMotionThreshold); + + /**users can point to their objects, userPointer is not used by Bullet */ + public native Pointer getUserPointer(); + + public native int getUserIndex(); + + public native int getUserIndex2(); + + public native int getUserIndex3(); + + /**users can point to their objects, userPointer is not used by Bullet */ + public native void setUserPointer(Pointer userPointer); + + /**users can point to their objects, userPointer is not used by Bullet */ + public native void setUserIndex(int index); + + public native void setUserIndex2(int index); + + public native void setUserIndex3(int index); + + public native int getUpdateRevisionInternal(); + + public native void setCustomDebugColor(@Const @ByRef btVector3 colorRGB); + + public native void removeCustomDebugColor(); + + public native @Cast("bool") boolean getCustomDebugColor(@ByRef btVector3 colorRGB); + + public native @Cast("bool") boolean checkCollideWith(@Const btCollisionObject co); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void serializeSingleObject(btSerializer serializer); +} + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btCollisionObjectDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCollisionObjectDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionObjectDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObjectDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCollisionObjectDoubleData position(long position) { + return (btCollisionObjectDoubleData)super.position(position); + } + @Override public btCollisionObjectDoubleData getPointer(long i) { + return new btCollisionObjectDoubleData((Pointer)this).offsetAddress(i); + } + + public native Pointer m_broadphaseHandle(); public native btCollisionObjectDoubleData m_broadphaseHandle(Pointer setter); + public native Pointer m_collisionShape(); public native btCollisionObjectDoubleData m_collisionShape(Pointer setter); + public native btCollisionShapeData m_rootCollisionShape(); public native btCollisionObjectDoubleData m_rootCollisionShape(btCollisionShapeData setter); + public native @Cast("char*") BytePointer m_name(); public native btCollisionObjectDoubleData m_name(BytePointer setter); + + public native @ByRef btTransformDoubleData m_worldTransform(); public native btCollisionObjectDoubleData m_worldTransform(btTransformDoubleData setter); + public native @ByRef btTransformDoubleData m_interpolationWorldTransform(); public native btCollisionObjectDoubleData m_interpolationWorldTransform(btTransformDoubleData setter); + public native @ByRef btVector3DoubleData m_interpolationLinearVelocity(); public native btCollisionObjectDoubleData m_interpolationLinearVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_interpolationAngularVelocity(); public native btCollisionObjectDoubleData m_interpolationAngularVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_anisotropicFriction(); public native btCollisionObjectDoubleData m_anisotropicFriction(btVector3DoubleData setter); + public native double m_contactProcessingThreshold(); public native btCollisionObjectDoubleData m_contactProcessingThreshold(double setter); + public native double m_deactivationTime(); public native btCollisionObjectDoubleData m_deactivationTime(double setter); + public native double m_friction(); public native btCollisionObjectDoubleData m_friction(double setter); + public native double m_rollingFriction(); public native btCollisionObjectDoubleData m_rollingFriction(double setter); + public native double m_contactDamping(); public native btCollisionObjectDoubleData m_contactDamping(double setter); + public native double m_contactStiffness(); public native btCollisionObjectDoubleData m_contactStiffness(double setter); + public native double m_restitution(); public native btCollisionObjectDoubleData m_restitution(double setter); + public native double m_hitFraction(); public native btCollisionObjectDoubleData m_hitFraction(double setter); + public native double m_ccdSweptSphereRadius(); public native btCollisionObjectDoubleData m_ccdSweptSphereRadius(double setter); + public native double m_ccdMotionThreshold(); public native btCollisionObjectDoubleData m_ccdMotionThreshold(double setter); + public native int m_hasAnisotropicFriction(); public native btCollisionObjectDoubleData m_hasAnisotropicFriction(int setter); + public native int m_collisionFlags(); public native btCollisionObjectDoubleData m_collisionFlags(int setter); + public native int m_islandTag1(); public native btCollisionObjectDoubleData m_islandTag1(int setter); + public native int m_companionId(); public native btCollisionObjectDoubleData m_companionId(int setter); + public native int m_activationState1(); public native btCollisionObjectDoubleData m_activationState1(int setter); + public native int m_internalType(); public native btCollisionObjectDoubleData m_internalType(int setter); + public native int m_checkCollideWith(); public native btCollisionObjectDoubleData m_checkCollideWith(int setter); + public native int m_collisionFilterGroup(); public native btCollisionObjectDoubleData m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native btCollisionObjectDoubleData m_collisionFilterMask(int setter); + public native int m_uniqueId(); public native btCollisionObjectDoubleData m_uniqueId(int setter);//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btCollisionObjectFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCollisionObjectFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionObjectFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObjectFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCollisionObjectFloatData position(long position) { + return (btCollisionObjectFloatData)super.position(position); + } + @Override public btCollisionObjectFloatData getPointer(long i) { + return new btCollisionObjectFloatData((Pointer)this).offsetAddress(i); + } + + public native Pointer m_broadphaseHandle(); public native btCollisionObjectFloatData m_broadphaseHandle(Pointer setter); + public native Pointer m_collisionShape(); public native btCollisionObjectFloatData m_collisionShape(Pointer setter); + public native btCollisionShapeData m_rootCollisionShape(); public native btCollisionObjectFloatData m_rootCollisionShape(btCollisionShapeData setter); + public native @Cast("char*") BytePointer m_name(); public native btCollisionObjectFloatData m_name(BytePointer setter); + + public native @ByRef btTransformFloatData m_worldTransform(); public native btCollisionObjectFloatData m_worldTransform(btTransformFloatData setter); + public native @ByRef btTransformFloatData m_interpolationWorldTransform(); public native btCollisionObjectFloatData m_interpolationWorldTransform(btTransformFloatData setter); + public native @ByRef btVector3FloatData m_interpolationLinearVelocity(); public native btCollisionObjectFloatData m_interpolationLinearVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_interpolationAngularVelocity(); public native btCollisionObjectFloatData m_interpolationAngularVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_anisotropicFriction(); public native btCollisionObjectFloatData m_anisotropicFriction(btVector3FloatData setter); + public native float m_contactProcessingThreshold(); public native btCollisionObjectFloatData m_contactProcessingThreshold(float setter); + public native float m_deactivationTime(); public native btCollisionObjectFloatData m_deactivationTime(float setter); + public native float m_friction(); public native btCollisionObjectFloatData m_friction(float setter); + public native float m_rollingFriction(); public native btCollisionObjectFloatData m_rollingFriction(float setter); + public native float m_contactDamping(); public native btCollisionObjectFloatData m_contactDamping(float setter); + public native float m_contactStiffness(); public native btCollisionObjectFloatData m_contactStiffness(float setter); + public native float m_restitution(); public native btCollisionObjectFloatData m_restitution(float setter); + public native float m_hitFraction(); public native btCollisionObjectFloatData m_hitFraction(float setter); + public native float m_ccdSweptSphereRadius(); public native btCollisionObjectFloatData m_ccdSweptSphereRadius(float setter); + public native float m_ccdMotionThreshold(); public native btCollisionObjectFloatData m_ccdMotionThreshold(float setter); + public native int m_hasAnisotropicFriction(); public native btCollisionObjectFloatData m_hasAnisotropicFriction(int setter); + public native int m_collisionFlags(); public native btCollisionObjectFloatData m_collisionFlags(int setter); + public native int m_islandTag1(); public native btCollisionObjectFloatData m_islandTag1(int setter); + public native int m_companionId(); public native btCollisionObjectFloatData m_companionId(int setter); + public native int m_activationState1(); public native btCollisionObjectFloatData m_activationState1(int setter); + public native int m_internalType(); public native btCollisionObjectFloatData m_internalType(int setter); + public native int m_checkCollideWith(); public native btCollisionObjectFloatData m_checkCollideWith(int setter); + public native int m_collisionFilterGroup(); public native btCollisionObjectFloatData m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native btCollisionObjectFloatData m_collisionFilterMask(int setter); + public native int m_uniqueId(); public native btCollisionObjectFloatData m_uniqueId(int setter); +} +// clang-format on + + + +// #endif //BT_COLLISION_OBJECT_H + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionCreateFunc.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_CREATE_FUNC +// #define BT_COLLISION_CREATE_FUNC + +// #include "LinearMath/btAlignedObjectArray.h" +@Opaque public static class btCollisionAlgorithmConstructionInfo extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionAlgorithmConstructionInfo() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionAlgorithmConstructionInfo(Pointer p) { super(p); } +} + +/**Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm */ +@NoOffset public static class btCollisionAlgorithmCreateFunc extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionAlgorithmCreateFunc(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionAlgorithmCreateFunc(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCollisionAlgorithmCreateFunc position(long position) { + return (btCollisionAlgorithmCreateFunc)super.position(position); + } + @Override public btCollisionAlgorithmCreateFunc getPointer(long i) { + return new btCollisionAlgorithmCreateFunc((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") boolean m_swapped(); public native btCollisionAlgorithmCreateFunc m_swapped(boolean setter); + + public btCollisionAlgorithmCreateFunc() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo arg0, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); +} +// #endif //BT_COLLISION_CREATE_FUNC + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionDispatcher.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION__DISPATCHER_H +// #define BT_COLLISION__DISPATCHER_H + +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +// #include "BulletCollision/CollisionDispatch/btManifoldResult.h" + +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "LinearMath/btAlignedObjectArray.h" +@Opaque public static class btCollisionConfiguration extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionConfiguration() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionConfiguration(Pointer p) { super(p); } +} + +// #include "btCollisionCreateFunc.h" + +public static final int USE_DISPATCH_REGISTRY_ARRAY = 1; +/**user can override this nearcallback for collision filtering and more finegrained control over collision detection */ +public static class btNearCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btNearCallback(Pointer p) { super(p); } + protected btNearCallback() { allocate(); } + private native void allocate(); + public native void call(@ByRef btBroadphasePair collisionPair, @ByRef btCollisionDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); +} + +/**btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs. + * Time of Impact, Closest Points and Penetration Depth. */ +@NoOffset public static class btCollisionDispatcher extends btDispatcher { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionDispatcher(Pointer p) { super(p); } + + /** enum btCollisionDispatcher::DispatcherFlags */ + public static final int + CD_STATIC_STATIC_REPORTED = 1, + CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD = 2, + CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION = 4; + + public native int getDispatcherFlags(); + + public native void setDispatcherFlags(int flags); + + /**registerCollisionCreateFunc allows registration of custom/alternative collision create functions */ + public native void registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc createFunc); + + public native void registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc createFunc); + + public native int getNumManifolds(); + + public native @Cast("btPersistentManifold**") PointerPointer getInternalManifoldPointer(); + + public native btPersistentManifold getManifoldByIndexInternal(int index); + + public btCollisionDispatcher(btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(collisionConfiguration); } + private native void allocate(btCollisionConfiguration collisionConfiguration); + + public native btPersistentManifold getNewManifold(@Const btCollisionObject b0, @Const btCollisionObject b1); + + public native void releaseManifold(btPersistentManifold manifold); + + public native void clearManifold(btPersistentManifold manifold); + + public native btCollisionAlgorithm findAlgorithm(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold, @Cast("ebtDispatcherQueryType") int queryType); + + public native @Cast("bool") boolean needsCollision(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native @Cast("bool") boolean needsResponse(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native void dispatchAllCollisionPairs(btOverlappingPairCache pairCache, @Const @ByRef btDispatcherInfo dispatchInfo, btDispatcher dispatcher); + + public native void setNearCallback(btNearCallback nearCallback); + + public native btNearCallback getNearCallback(); + + //by default, Bullet will use this near callback + public static native void defaultNearCallback(@ByRef btBroadphasePair collisionPair, @ByRef btCollisionDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); + + public native Pointer allocateCollisionAlgorithm(int size); + + public native void freeCollisionAlgorithm(Pointer ptr); + + public native btCollisionConfiguration getCollisionConfiguration(); + + public native void setCollisionConfiguration(btCollisionConfiguration config); + + public native btPoolAllocator getInternalManifoldPool(); +} + +// #endif //BT_COLLISION__DISPATCHER_H + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/** + * \mainpage Bullet Documentation + * + * \section intro_sec Introduction + * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ). + * + * The main documentation is Bullet_User_Manual.pdf, included in the source code distribution. + * There is the Physics Forum for feedback and general Collision Detection and Physics discussions. + * Please visit http://www.bulletphysics.org + * + * \section install_sec Installation + * + * \subsection step1 Step 1: Download + * You can download the Bullet Physics Library from the github repository: https://github.com/bulletphysics/bullet3/releases + * + * \subsection step2 Step 2: Building + * Bullet has multiple build systems, including premake, cmake and autotools. Premake and cmake support all platforms. + * Premake is included in the Bullet/build folder for Windows, Mac OSX and Linux. + * Under Windows you can click on Bullet/build/vs2010.bat to create Microsoft Visual Studio projects. + * On Mac OSX and Linux you can open a terminal and generate Makefile, codeblocks or Xcode4 projects: + * cd Bullet/build + * ./premake4_osx gmake or ./premake4_linux gmake or ./premake4_linux64 gmake or (for Mac) ./premake4_osx xcode4 + * cd Bullet/build/gmake + * make + * + * An alternative to premake is cmake. You can download cmake from http://www.cmake.org + * cmake can autogenerate projectfiles for Microsoft Visual Studio, Apple Xcode, KDevelop and Unix Makefiles. + * The easiest is to run the CMake cmake-gui graphical user interface and choose the options and generate projectfiles. + * You can also use cmake in the command-line. Here are some examples for various platforms: + * cmake . -G "Visual Studio 9 2008" + * cmake . -G Xcode + * cmake . -G "Unix Makefiles" + * Although cmake is recommended, you can also use autotools for UNIX: ./autogen.sh ./configure to create a Makefile and then run make. + * + * \subsection step3 Step 3: Testing demos + * Try to run and experiment with BasicDemo executable as a starting point. + * Bullet can be used in several ways, as Full Rigid Body simulation, as Collision Detector Library or Low Level / Snippets like the GJK Closest Point calculation. + * The Dependencies can be seen in this documentation under Directories + * + * \subsection step4 Step 4: Integrating in your application, full Rigid Body and Soft Body simulation + * Check out BasicDemo how to create a btDynamicsWorld, btRigidBody and btCollisionShape, Stepping the simulation and synchronizing your graphics object transform. + * Check out SoftDemo how to use soft body dynamics, using btSoftRigidDynamicsWorld. + * \subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras) + * Bullet Collision Detection can also be used without the Dynamics/Extras. + * Check out btCollisionWorld and btCollisionObject, and the CollisionInterfaceDemo. + * \subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation. + * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of btGjkPairDetector. + * + * \section copyright Copyright + * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf + * + */ + +// #ifndef BT_COLLISION_WORLD_H +// #define BT_COLLISION_WORLD_H +@Opaque public static class btConvexShape extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btConvexShape() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexShape(Pointer p) { super(p); } +} + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "btCollisionObject.h" +// #include "btCollisionDispatcher.h" +// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +// #include "LinearMath/btAlignedObjectArray.h" + +/**CollisionWorld is interface and container for the collision detection */ +@NoOffset public static class btCollisionWorld extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionWorld(Pointer p) { super(p); } + + //this constructor doesn't own the dispatcher and paircache/broadphase + public btCollisionWorld(btDispatcher dispatcher, btBroadphaseInterface broadphasePairCache, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, broadphasePairCache, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface broadphasePairCache, btCollisionConfiguration collisionConfiguration); + + public native void setBroadphase(btBroadphaseInterface pairCache); + + public native btBroadphaseInterface getBroadphase(); + + public native btOverlappingPairCache getPairCache(); + + public native btDispatcher getDispatcher(); + + public native void updateSingleAabb(btCollisionObject colObj); + + public native void updateAabbs(); + + /**the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSimulation) + * it can be useful to use if you perform ray tests without collision detection/simulation */ + public native void computeOverlappingPairs(); + + public native void setDebugDrawer(btIDebugDraw debugDrawer); + + public native btIDebugDraw getDebugDrawer(); + + public native void debugDrawWorld(); + + public native void debugDrawObject(@Const @ByRef btTransform worldTransform, @Const btCollisionShape shape, @Const @ByRef btVector3 color); + + /**LocalShapeInfo gives extra information for complex shapes + * Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart */ + public static class LocalShapeInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public LocalShapeInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public LocalShapeInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LocalShapeInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public LocalShapeInfo position(long position) { + return (LocalShapeInfo)super.position(position); + } + @Override public LocalShapeInfo getPointer(long i) { + return new LocalShapeInfo((Pointer)this).offsetAddress(i); + } + + public native int m_shapePart(); public native LocalShapeInfo m_shapePart(int setter); + public native int m_triangleIndex(); public native LocalShapeInfo m_triangleIndex(int setter); + + //const btCollisionShape* m_shapeTemp; + //const btTransform* m_shapeLocalTransform; + } + + @NoOffset public static class LocalRayResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LocalRayResult(Pointer p) { super(p); } + + public LocalRayResult(@Const btCollisionObject collisionObject, + LocalShapeInfo localShapeInfo, + @Const @ByRef btVector3 hitNormalLocal, + @Cast("btScalar") float hitFraction) { super((Pointer)null); allocate(collisionObject, localShapeInfo, hitNormalLocal, hitFraction); } + private native void allocate(@Const btCollisionObject collisionObject, + LocalShapeInfo localShapeInfo, + @Const @ByRef btVector3 hitNormalLocal, + @Cast("btScalar") float hitFraction); + + public native @Const btCollisionObject m_collisionObject(); public native LocalRayResult m_collisionObject(btCollisionObject setter); + public native LocalShapeInfo m_localShapeInfo(); public native LocalRayResult m_localShapeInfo(LocalShapeInfo setter); + public native @ByRef btVector3 m_hitNormalLocal(); public native LocalRayResult m_hitNormalLocal(btVector3 setter); + public native @Cast("btScalar") float m_hitFraction(); public native LocalRayResult m_hitFraction(float setter); + } + + /**RayResultCallback is used to report new raycast results */ + @NoOffset public static class RayResultCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RayResultCallback(Pointer p) { super(p); } + + public native @Cast("btScalar") float m_closestHitFraction(); public native RayResultCallback m_closestHitFraction(float setter); + public native @Const btCollisionObject m_collisionObject(); public native RayResultCallback m_collisionObject(btCollisionObject setter); + public native int m_collisionFilterGroup(); public native RayResultCallback m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native RayResultCallback m_collisionFilterMask(int setter); + //@BP Mod - Custom flags, currently used to enable backface culling on tri-meshes, see btRaycastCallback.h. Apply any of the EFlags defined there on m_flags here to invoke. + public native @Cast("unsigned int") int m_flags(); public native RayResultCallback m_flags(int setter); + public native @Cast("bool") boolean hasHit(); + + public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); + } + + @NoOffset public static class ClosestRayResultCallback extends RayResultCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ClosestRayResultCallback(Pointer p) { super(p); } + + public ClosestRayResultCallback(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld) { super((Pointer)null); allocate(rayFromWorld, rayToWorld); } + private native void allocate(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld); + + public native @ByRef btVector3 m_rayFromWorld(); public native ClosestRayResultCallback m_rayFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction + public native @ByRef btVector3 m_rayToWorld(); public native ClosestRayResultCallback m_rayToWorld(btVector3 setter); + + public native @ByRef btVector3 m_hitNormalWorld(); public native ClosestRayResultCallback m_hitNormalWorld(btVector3 setter); + public native @ByRef btVector3 m_hitPointWorld(); public native ClosestRayResultCallback m_hitPointWorld(btVector3 setter); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); + } + + @NoOffset public static class AllHitsRayResultCallback extends RayResultCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public AllHitsRayResultCallback(Pointer p) { super(p); } + + public AllHitsRayResultCallback(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld) { super((Pointer)null); allocate(rayFromWorld, rayToWorld); } + private native void allocate(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld); + + + + public native @ByRef btVector3 m_rayFromWorld(); public native AllHitsRayResultCallback m_rayFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction + public native @ByRef btVector3 m_rayToWorld(); public native AllHitsRayResultCallback m_rayToWorld(btVector3 setter); + + public native @ByRef btAlignedObjectArray_btVector3 m_hitNormalWorld(); public native AllHitsRayResultCallback m_hitNormalWorld(btAlignedObjectArray_btVector3 setter); + public native @ByRef btAlignedObjectArray_btVector3 m_hitPointWorld(); public native AllHitsRayResultCallback m_hitPointWorld(btAlignedObjectArray_btVector3 setter); + public native @ByRef btAlignedObjectArray_btScalar m_hitFractions(); public native AllHitsRayResultCallback m_hitFractions(btAlignedObjectArray_btScalar setter); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); + } + + @NoOffset public static class LocalConvexResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LocalConvexResult(Pointer p) { super(p); } + + public LocalConvexResult(@Const btCollisionObject hitCollisionObject, + LocalShapeInfo localShapeInfo, + @Const @ByRef btVector3 hitNormalLocal, + @Const @ByRef btVector3 hitPointLocal, + @Cast("btScalar") float hitFraction) { super((Pointer)null); allocate(hitCollisionObject, localShapeInfo, hitNormalLocal, hitPointLocal, hitFraction); } + private native void allocate(@Const btCollisionObject hitCollisionObject, + LocalShapeInfo localShapeInfo, + @Const @ByRef btVector3 hitNormalLocal, + @Const @ByRef btVector3 hitPointLocal, + @Cast("btScalar") float hitFraction); + + public native @Const btCollisionObject m_hitCollisionObject(); public native LocalConvexResult m_hitCollisionObject(btCollisionObject setter); + public native LocalShapeInfo m_localShapeInfo(); public native LocalConvexResult m_localShapeInfo(LocalShapeInfo setter); + public native @ByRef btVector3 m_hitNormalLocal(); public native LocalConvexResult m_hitNormalLocal(btVector3 setter); + public native @ByRef btVector3 m_hitPointLocal(); public native LocalConvexResult m_hitPointLocal(btVector3 setter); + public native @Cast("btScalar") float m_hitFraction(); public native LocalConvexResult m_hitFraction(float setter); + } + + /**RayResultCallback is used to report new raycast results */ + @NoOffset public static class ConvexResultCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ConvexResultCallback(Pointer p) { super(p); } + + public native @Cast("btScalar") float m_closestHitFraction(); public native ConvexResultCallback m_closestHitFraction(float setter); + public native int m_collisionFilterGroup(); public native ConvexResultCallback m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native ConvexResultCallback m_collisionFilterMask(int setter); + + public native @Cast("bool") boolean hasHit(); + + public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalConvexResult convexResult, @Cast("bool") boolean normalInWorldSpace); + } + + @NoOffset public static class ClosestConvexResultCallback extends ConvexResultCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ClosestConvexResultCallback(Pointer p) { super(p); } + + public ClosestConvexResultCallback(@Const @ByRef btVector3 convexFromWorld, @Const @ByRef btVector3 convexToWorld) { super((Pointer)null); allocate(convexFromWorld, convexToWorld); } + private native void allocate(@Const @ByRef btVector3 convexFromWorld, @Const @ByRef btVector3 convexToWorld); + + public native @ByRef btVector3 m_convexFromWorld(); public native ClosestConvexResultCallback m_convexFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction + public native @ByRef btVector3 m_convexToWorld(); public native ClosestConvexResultCallback m_convexToWorld(btVector3 setter); + + public native @ByRef btVector3 m_hitNormalWorld(); public native ClosestConvexResultCallback m_hitNormalWorld(btVector3 setter); + public native @ByRef btVector3 m_hitPointWorld(); public native ClosestConvexResultCallback m_hitPointWorld(btVector3 setter); + public native @Const btCollisionObject m_hitCollisionObject(); public native ClosestConvexResultCallback m_hitCollisionObject(btCollisionObject setter); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalConvexResult convexResult, @Cast("bool") boolean normalInWorldSpace); + } + + /**ContactResultCallback is used to report contact points */ + @NoOffset public static class ContactResultCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ContactResultCallback(Pointer p) { super(p); } + + public native int m_collisionFilterGroup(); public native ContactResultCallback m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native ContactResultCallback m_collisionFilterMask(int setter); + public native @Cast("btScalar") float m_closestDistanceThreshold(); public native ContactResultCallback m_closestDistanceThreshold(float setter); + + public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); + + public native @Cast("btScalar") float addSingleResult(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper colObj0Wrap, int partId0, int index0, @Const btCollisionObjectWrapper colObj1Wrap, int partId1, int index1); + } + + public native int getNumCollisionObjects(); + + /** rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback + * This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback. */ + public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); + + /** convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback + * This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback. */ + public native void convexSweepTest(@Const btConvexShape castShape, @Const @ByRef btTransform from, @Const @ByRef btTransform to, @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedCcdPenetration/*=btScalar(0.)*/); + public native void convexSweepTest(@Const btConvexShape castShape, @Const @ByRef btTransform from, @Const @ByRef btTransform to, @ByRef ConvexResultCallback resultCallback); + + /**contactTest performs a discrete collision test between colObj against all objects in the btCollisionWorld, and calls the resultCallback. + * it reports one or more contact points for every overlapping object (including the one with deepest penetration) */ + public native void contactTest(btCollisionObject colObj, @ByRef ContactResultCallback resultCallback); + + /**contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected. + * it reports one or more contact points (including the one with deepest penetration) */ + public native void contactPairTest(btCollisionObject colObjA, btCollisionObject colObjB, @ByRef ContactResultCallback resultCallback); + + /** rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest. + * In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape. + * This allows more customization. */ + public static native void rayTestSingle(@Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, + btCollisionObject collisionObject, + @Const btCollisionShape collisionShape, + @Const @ByRef btTransform colObjWorldTransform, + @ByRef RayResultCallback resultCallback); + + public static native void rayTestSingleInternal(@Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, + @Const btCollisionObjectWrapper collisionObjectWrap, + @ByRef RayResultCallback resultCallback); + + /** objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest. */ + public static native void objectQuerySingle(@Const btConvexShape castShape, @Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, + btCollisionObject collisionObject, + @Const btCollisionShape collisionShape, + @Const @ByRef btTransform colObjWorldTransform, + @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedPenetration); + + public static native void objectQuerySingleInternal(@Const btConvexShape castShape, @Const @ByRef btTransform convexFromTrans, @Const @ByRef btTransform convexToTrans, + @Const btCollisionObjectWrapper colObjWrap, + @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedPenetration); + + public native void addCollisionObject(btCollisionObject collisionObject, int collisionFilterGroup/*=btBroadphaseProxy::DefaultFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter*/); + public native void addCollisionObject(btCollisionObject collisionObject); + + public native void refreshBroadphaseProxy(btCollisionObject collisionObject); + + public native @Cast("btCollisionObjectArray*") @ByRef btAlignedObjectArray_btVector3 getCollisionObjectArray(); + + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native void performDiscreteCollisionDetection(); + + public native @ByRef btDispatcherInfo getDispatchInfo(); + + public native @Cast("bool") boolean getForceUpdateAllAabbs(); + public native void setForceUpdateAllAabbs(@Cast("bool") boolean forceUpdateAllAabbs); + + /**Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bullet/Demos/SerializeDemo) */ + public native void serialize(btSerializer serializer); +} + +// #endif //BT_COLLISION_WORLD_H + + +// Parsed from BulletCollision/CollisionDispatch/btManifoldResult.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MANIFOLD_RESULT_H +// #define BT_MANIFOLD_RESULT_H + +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" + +// #include "LinearMath/btTransform.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" + +public static class ContactAddedCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ContactAddedCallback(Pointer p) { super(p); } + protected ContactAddedCallback() { allocate(); } + private native void allocate(); + public native @Cast("bool") boolean call(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper colObj0Wrap, int partId0, int index0, @Const btCollisionObjectWrapper colObj1Wrap, int partId1, int index1); +} +public static native ContactAddedCallback gContactAddedCallback(); public static native void gContactAddedCallback(ContactAddedCallback setter); + +//#define DEBUG_PART_INDEX 1 + +/** These callbacks are used to customize the algorith that combine restitution, friction, damping, Stiffness */ +public static class CalculateCombinedCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CalculateCombinedCallback(Pointer p) { super(p); } + protected CalculateCombinedCallback() { allocate(); } + private native void allocate(); + public native @Cast("btScalar") float call(@Const btCollisionObject body0, @Const btCollisionObject body1); +} + +public static native CalculateCombinedCallback gCalculateCombinedRestitutionCallback(); public static native void gCalculateCombinedRestitutionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedFrictionCallback(); public static native void gCalculateCombinedFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback(); public static native void gCalculateCombinedRollingFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback(); public static native void gCalculateCombinedSpinningFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedContactDampingCallback(); public static native void gCalculateCombinedContactDampingCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback(); public static native void gCalculateCombinedContactStiffnessCallback(CalculateCombinedCallback setter); + +/**btManifoldResult is a helper class to manage contact results. */ +@NoOffset public static class btManifoldResult extends btDiscreteCollisionDetectorInterface.Result { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btManifoldResult(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btManifoldResult(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btManifoldResult position(long position) { + return (btManifoldResult)super.position(position); + } + @Override public btManifoldResult getPointer(long i) { + return new btManifoldResult((Pointer)this).offsetAddress(i); + } + + public btManifoldResult() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btManifoldResult(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap) { super((Pointer)null); allocate(body0Wrap, body1Wrap); } + private native void allocate(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + + public native void setPersistentManifold(btPersistentManifold manifoldPtr); + public native btPersistentManifold getPersistentManifold(); + + public native void setShapeIdentifiersA(int partId0, int index0); + + public native void setShapeIdentifiersB(int partId1, int index1); + + public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); + + public native void refreshContactPoints(); + + public native @Const btCollisionObjectWrapper getBody0Wrap(); + public native @Const btCollisionObjectWrapper getBody1Wrap(); + + public native void setBody0Wrap(@Const btCollisionObjectWrapper obj0Wrap); + + public native void setBody1Wrap(@Const btCollisionObjectWrapper obj1Wrap); + + public native @Const btCollisionObject getBody0Internal(); + + public native @Const btCollisionObject getBody1Internal(); + + public native @Cast("btScalar") float m_closestPointDistanceThreshold(); public native btManifoldResult m_closestPointDistanceThreshold(float setter); + + /** in the future we can let the user override the methods to combine restitution and friction */ + public static native @Cast("btScalar") float calculateCombinedRestitution(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedRollingFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedSpinningFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedContactDamping(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedContactStiffness(@Const btCollisionObject body0, @Const btCollisionObject body1); +} + +// #endif //BT_MANIFOLD_RESULT_H + + +// Parsed from BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H +// #define __BT_ACTIVATING_COLLISION_ALGORITHM_H + +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" + +/**This class is not enabled yet (work-in-progress) to more aggressively activate objects. */ +public static class btActivatingCollisionAlgorithm extends btCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btActivatingCollisionAlgorithm(Pointer p) { super(p); } + +} +// #endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H + + +// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H + +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "btCollisionDispatcher.h" + +/** btSphereSphereCollisionAlgorithm provides sphere-sphere collision detection. + * Other features are frame-coherency (persistent data) and collision response. + * Also provides the most basic sample for custom/user btCollisionAlgorithm */ +@NoOffset public static class btSphereSphereCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSphereSphereCollisionAlgorithm(Pointer p) { super(p); } + + public btSphereSphereCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap) { super((Pointer)null); allocate(mf, ci, col0Wrap, col1Wrap); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap); + + public btSphereSphereCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap); + } +} + +// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H + + +// Parsed from BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DEFAULT_COLLISION_CONFIGURATION +// #define BT_DEFAULT_COLLISION_CONFIGURATION + +// #include "btCollisionConfiguration.h" +@Opaque public static class btVoronoiSimplexSolver extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btVoronoiSimplexSolver() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVoronoiSimplexSolver(Pointer p) { super(p); } +} +@Opaque public static class btConvexPenetrationDepthSolver extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btConvexPenetrationDepthSolver() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexPenetrationDepthSolver(Pointer p) { super(p); } +} + +@NoOffset public static class btDefaultCollisionConstructionInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultCollisionConstructionInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultCollisionConstructionInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultCollisionConstructionInfo position(long position) { + return (btDefaultCollisionConstructionInfo)super.position(position); + } + @Override public btDefaultCollisionConstructionInfo getPointer(long i) { + return new btDefaultCollisionConstructionInfo((Pointer)this).offsetAddress(i); + } + + public native btPoolAllocator m_persistentManifoldPool(); public native btDefaultCollisionConstructionInfo m_persistentManifoldPool(btPoolAllocator setter); + public native btPoolAllocator m_collisionAlgorithmPool(); public native btDefaultCollisionConstructionInfo m_collisionAlgorithmPool(btPoolAllocator setter); + public native int m_defaultMaxPersistentManifoldPoolSize(); public native btDefaultCollisionConstructionInfo m_defaultMaxPersistentManifoldPoolSize(int setter); + public native int m_defaultMaxCollisionAlgorithmPoolSize(); public native btDefaultCollisionConstructionInfo m_defaultMaxCollisionAlgorithmPoolSize(int setter); + public native int m_customCollisionAlgorithmMaxElementSize(); public native btDefaultCollisionConstructionInfo m_customCollisionAlgorithmMaxElementSize(int setter); + public native int m_useEpaPenetrationAlgorithm(); public native btDefaultCollisionConstructionInfo m_useEpaPenetrationAlgorithm(int setter); + + public btDefaultCollisionConstructionInfo() { super((Pointer)null); allocate(); } + private native void allocate(); +} + +/**btCollisionConfiguration allows to configure Bullet collision detection + * stack allocator, pool memory allocators + * \todo: describe the meaning */ +@NoOffset public static class btDefaultCollisionConfiguration extends btCollisionConfiguration { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultCollisionConfiguration(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultCollisionConfiguration(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultCollisionConfiguration position(long position) { + return (btDefaultCollisionConfiguration)super.position(position); + } + @Override public btDefaultCollisionConfiguration getPointer(long i) { + return new btDefaultCollisionConfiguration((Pointer)this).offsetAddress(i); + } + + public btDefaultCollisionConfiguration(@Const @ByRef(nullValue = "btDefaultCollisionConstructionInfo()") btDefaultCollisionConstructionInfo constructionInfo) { super((Pointer)null); allocate(constructionInfo); } + private native void allocate(@Const @ByRef(nullValue = "btDefaultCollisionConstructionInfo()") btDefaultCollisionConstructionInfo constructionInfo); + public btDefaultCollisionConfiguration() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**memory pools */ + public native btPoolAllocator getPersistentManifoldPool(); + + public native btPoolAllocator getCollisionAlgorithmPool(); + + public native btCollisionAlgorithmCreateFunc getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1); + + public native btCollisionAlgorithmCreateFunc getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1); + + /**Use this method to allow to generate multiple contact points between at once, between two objects using the generic convex-convex algorithm. + * By default, this feature is disabled for best performance. + * @param numPerturbationIterations controls the number of collision queries. Set it to zero to disable the feature. + * @param minimumPointsPerturbationThreshold is the minimum number of points in the contact cache, above which the feature is disabled + * 3 is a good value for both params, if you want to enable the feature. This is because the default contact cache contains a maximum of 4 points, and one collision query at the unperturbed orientation is performed first. + * See Bullet/Demos/CollisionDemo for an example how this feature gathers multiple points. + * \todo we could add a per-object setting of those parameters, for level-of-detail collision detection. */ + public native void setConvexConvexMultipointIterations(int numPerturbationIterations/*=3*/, int minimumPointsPerturbationThreshold/*=3*/); + public native void setConvexConvexMultipointIterations(); + + public native void setPlaneConvexMultipointIterations(int numPerturbationIterations/*=3*/, int minimumPointsPerturbationThreshold/*=3*/); + public native void setPlaneConvexMultipointIterations(); +} + +// #endif //BT_DEFAULT_COLLISION_CONFIGURATION + + +// Parsed from BulletCollision/CollisionShapes/btCollisionShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_SHAPE_H +// #define BT_COLLISION_SHAPE_H + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types + +/**The btCollisionShape class provides an interface for collision shapes that can be shared among btCollisionObjects. */ +@NoOffset public static class btCollisionShape extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionShape(Pointer p) { super(p); } + + + /**getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t. */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef FloatPointer radius); + public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef FloatBuffer radius); + public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef float[] radius); + + /**getAngularMotionDisc returns the maximum radius needed for Conservative Advancement to handle time-of-impact with rotations. */ + public native @Cast("btScalar") float getAngularMotionDisc(); + + public native @Cast("btScalar") float getContactBreakingThreshold(@Cast("btScalar") float defaultContactThresholdFactor); + + /**calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep) + * result is conservative */ + public native void calculateTemporalAabb(@Const @ByRef btTransform curTrans, @Const @ByRef btVector3 linvel, @Const @ByRef btVector3 angvel, @Cast("btScalar") float timeStep, @ByRef btVector3 temporalAabbMin, @ByRef btVector3 temporalAabbMax); + + public native @Cast("bool") boolean isPolyhedral(); + + public native @Cast("bool") boolean isConvex2d(); + + public native @Cast("bool") boolean isConvex(); + public native @Cast("bool") boolean isNonMoving(); + public native @Cast("bool") boolean isConcave(); + public native @Cast("bool") boolean isCompound(); + + public native @Cast("bool") boolean isSoftBody(); + + /**isInfinite is used to catch simulation error (aabb check) */ + public native @Cast("bool") boolean isInfinite(); + +// #ifndef __SPU__ + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + //debugging support + public native @Cast("const char*") BytePointer getName(); +// #endif //__SPU__ + + public native int getShapeType(); + + /**the getAnisotropicRollingFrictionDirection can be used in combination with setAnisotropicFriction + * See Bullet/Demos/RollingFrictionDemo for an example */ + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + + /**optional user data pointer */ + public native void setUserPointer(Pointer userPtr); + + public native Pointer getUserPointer(); + public native void setUserIndex(int index); + + public native int getUserIndex(); + + public native void setUserIndex2(int index); + + public native int getUserIndex2(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void serializeSingleShape(btSerializer serializer); +} + +// clang-format off +// parser needs * with the name +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btCollisionShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCollisionShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCollisionShapeData position(long position) { + return (btCollisionShapeData)super.position(position); + } + @Override public btCollisionShapeData getPointer(long i) { + return new btCollisionShapeData((Pointer)this).offsetAddress(i); + } + + public native @Cast("char*") BytePointer m_name(); public native btCollisionShapeData m_name(BytePointer setter); + public native int m_shapeType(); public native btCollisionShapeData m_shapeType(int setter); + public native @Cast("char") byte m_padding(int i); public native btCollisionShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} +// clang-format on + + +// #endif //BT_COLLISION_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H +// #define BT_POLYHEDRAL_CONVEX_SHAPE_H + +// #include "LinearMath/btMatrix3x3.h" +// #include "btConvexInternalShape.h" +@Opaque public static class btConvexPolyhedron extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btConvexPolyhedron() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexPolyhedron(Pointer p) { super(p); } +} + +/**The btPolyhedralConvexShape is an internal interface class for polyhedral convex shapes. */ +@NoOffset public static class btPolyhedralConvexShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPolyhedralConvexShape(Pointer p) { super(p); } + + + /**optional method mainly used to generate multiple contact points by clipping polyhedral features (faces/edges) + * experimental/work-in-progress */ + public native @Cast("bool") boolean initializePolyhedralFeatures(int shiftVerticesByMargin/*=0*/); + public native @Cast("bool") boolean initializePolyhedralFeatures(); + + public native void setPolyhedralFeatures(@ByRef btConvexPolyhedron polyhedron); + + public native @Const btConvexPolyhedron getConvexPolyhedron(); + + //brute force implementations + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native int getNumVertices(); + public native int getNumEdges(); + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + public native void getVertex(int i, @ByRef btVector3 vtx); + public native int getNumPlanes(); + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + // virtual int getIndex(int i) const = 0 ; + + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); +} + +/**The btPolyhedralConvexAabbCachingShape adds aabb caching to the btPolyhedralConvexShape */ +@NoOffset public static class btPolyhedralConvexAabbCachingShape extends btPolyhedralConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPolyhedralConvexAabbCachingShape(Pointer p) { super(p); } + + public native void getNonvirtualAabb(@Const @ByRef btTransform trans, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax, @Cast("btScalar") float margin); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void recalcLocalAabb(); +} + +// #endif //BT_POLYHEDRAL_CONVEX_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexInternalShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_INTERNAL_SHAPE_H +// #define BT_CONVEX_INTERNAL_SHAPE_H + +// #include "btConvexShape.h" +// #include "LinearMath/btAabbUtil2.h" + +/**The btConvexInternalShape is an internal base class, shared by most convex shape implementations. + * The btConvexInternalShape uses a default collision margin set to CONVEX_DISTANCE_MARGIN. + * This collision margin used by Gjk and some other algorithms, see also btCollisionMargin.h + * Note that when creating small shapes (derived from btConvexInternalShape), + * you need to make sure to set a smaller collision margin, using the 'setMargin' API + * There is a automatic mechanism 'setSafeMargin' used by btBoxShape and btCylinderShape */ +@NoOffset public static class btConvexInternalShape extends btConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexInternalShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native @Const @ByRef btVector3 getImplicitShapeDimensions(); + + /**warning: use setImplicitShapeDimensions with care + * changing a collision shape while the body is in the world is not recommended, + * it is best to remove the body from the world, then make the change, and re-add it + * alternatively flush the contact points, see documentation for 'cleanProxyFromPairs' */ + public native void setImplicitShapeDimensions(@Const @ByRef btVector3 dimensions); + + public native void setSafeMargin(@Cast("btScalar") float minDimension, @Cast("btScalar") float defaultMarginMultiplier/*=0.1f*/); + public native void setSafeMargin(@Cast("btScalar") float minDimension); + public native void setSafeMargin(@Const @ByRef btVector3 halfExtents, @Cast("btScalar") float defaultMarginMultiplier/*=0.1f*/); + public native void setSafeMargin(@Const @ByRef btVector3 halfExtents); + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void getAabbSlow(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native @Const @ByRef btVector3 getLocalScalingNV(); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + + public native @Cast("btScalar") float getMarginNV(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btConvexInternalShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConvexInternalShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexInternalShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexInternalShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConvexInternalShapeData position(long position) { + return (btConvexInternalShapeData)super.position(position); + } + @Override public btConvexInternalShapeData getPointer(long i) { + return new btConvexInternalShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btConvexInternalShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native @ByRef btVector3FloatData m_localScaling(); public native btConvexInternalShapeData m_localScaling(btVector3FloatData setter); + + public native @ByRef btVector3FloatData m_implicitShapeDimensions(); public native btConvexInternalShapeData m_implicitShapeDimensions(btVector3FloatData setter); + + public native float m_collisionMargin(); public native btConvexInternalShapeData m_collisionMargin(float setter); + + public native int m_padding(); public native btConvexInternalShapeData m_padding(int setter); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +/**btConvexInternalAabbCachingShape adds local aabb caching for convex shapes, to avoid expensive bounding box calculations */ +@NoOffset public static class btConvexInternalAabbCachingShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexInternalAabbCachingShape(Pointer p) { super(p); } + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void recalcLocalAabb(); +} + +// #endif //BT_CONVEX_INTERNAL_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btBoxShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBB_BOX_MINKOWSKI_H +// #define BT_OBB_BOX_MINKOWSKI_H + +// #include "btPolyhedralConvexShape.h" +// #include "btCollisionMargin.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMinMax.h" + +/**The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space. */ +public static class btBoxShape extends btPolyhedralConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBoxShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 getHalfExtentsWithMargin(); + + public native @Const @ByRef btVector3 getHalfExtentsWithoutMargin(); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public btBoxShape(@Const @ByRef btVector3 boxHalfExtents) { super((Pointer)null); allocate(boxHalfExtents); } + private native void allocate(@Const @ByRef btVector3 boxHalfExtents); + + public native void setMargin(@Cast("btScalar") float collisionMargin); + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + + public native int getNumPlanes(); + + public native int getNumVertices(); + + public native int getNumEdges(); + + public native void getVertex(int i, @ByRef btVector3 vtx); + + public native void getPlaneEquation(@ByRef btVector4 plane, int i); + + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); +} + +// #endif //BT_OBB_BOX_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btSphereShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_SPHERE_MINKOWSKI_H +// #define BT_SPHERE_MINKOWSKI_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +/**The btSphereShape implements an implicit sphere, centered around a local origin with radius. */ +public static class btSphereShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSphereShape(Pointer p) { super(p); } + + + public btSphereShape(@Cast("btScalar") float radius) { super((Pointer)null); allocate(radius); } + private native void allocate(@Cast("btScalar") float radius); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + //notice that the vectors should be unit length + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native @Cast("btScalar") float getRadius(); + + public native void setUnscaledRadius(@Cast("btScalar") float radius); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); +} + +// #endif //BT_SPHERE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btCapsuleShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CAPSULE_SHAPE_H +// #define BT_CAPSULE_SHAPE_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +/**The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned around the X axis and btCapsuleShapeZ around the Z axis. + * The total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. + * The btCapsuleShape is a convex hull of two spheres. The btMultiSphereShape is a more general collision shape that takes the convex hull of multiple sphere, so it can also represent a capsule when just using two spheres. */ +@NoOffset public static class btCapsuleShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCapsuleShape(Pointer p) { super(p); } + + + public btCapsuleShape(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + /**CollisionShape Interface */ + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + /** btConvexShape Interface */ + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void setMargin(@Cast("btScalar") float collisionMargin); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native @Cast("const char*") BytePointer getName(); + + public native int getUpAxis(); + + public native @Cast("btScalar") float getRadius(); + + public native @Cast("btScalar") float getHalfHeight(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void deSerializeFloat(btCapsuleShapeData dataBuffer); +} + +/**btCapsuleShapeX represents a capsule around the Z axis + * the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. */ +public static class btCapsuleShapeX extends btCapsuleShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCapsuleShapeX(Pointer p) { super(p); } + + public btCapsuleShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} + +/**btCapsuleShapeZ represents a capsule around the Z axis + * the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. */ +public static class btCapsuleShapeZ extends btCapsuleShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCapsuleShapeZ(Pointer p) { super(p); } + + public btCapsuleShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btCapsuleShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCapsuleShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCapsuleShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCapsuleShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCapsuleShapeData position(long position) { + return (btCapsuleShapeData)super.position(position); + } + @Override public btCapsuleShapeData getPointer(long i) { + return new btCapsuleShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btCapsuleShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native int m_upAxis(); public native btCapsuleShapeData m_upAxis(int setter); + + public native @Cast("char") byte m_padding(int i); public native btCapsuleShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + + + +// #endif //BT_CAPSULE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btCylinderShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CYLINDER_MINKOWSKI_H +// #define BT_CYLINDER_MINKOWSKI_H + +// #include "btBoxShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btVector3.h" + +/** The btCylinderShape class implements a cylinder shape primitive, centered around the origin. Its central axis aligned with the Y axis. btCylinderShapeX is aligned with the X axis and btCylinderShapeZ around the Z axis. */ +@NoOffset public static class btCylinderShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCylinderShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 getHalfExtentsWithMargin(); + + public native @Const @ByRef btVector3 getHalfExtentsWithoutMargin(); + + public btCylinderShape(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } + private native void allocate(@Const @ByRef btVector3 halfExtents); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void setMargin(@Cast("btScalar") float collisionMargin); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + //use box inertia + // virtual void calculateLocalInertia(btScalar mass,btVector3& inertia) const; + + public native int getUpAxis(); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + public native @Cast("btScalar") float getRadius(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +public static class btCylinderShapeX extends btCylinderShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCylinderShapeX(Pointer p) { super(p); } + + + public btCylinderShapeX(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } + private native void allocate(@Const @ByRef btVector3 halfExtents); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native @Cast("btScalar") float getRadius(); +} + +public static class btCylinderShapeZ extends btCylinderShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCylinderShapeZ(Pointer p) { super(p); } + + + public btCylinderShapeZ(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } + private native void allocate(@Const @ByRef btVector3 halfExtents); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native @Cast("btScalar") float getRadius(); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btCylinderShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCylinderShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCylinderShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCylinderShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCylinderShapeData position(long position) { + return (btCylinderShapeData)super.position(position); + } + @Override public btCylinderShapeData getPointer(long i) { + return new btCylinderShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btCylinderShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native int m_upAxis(); public native btCylinderShapeData m_upAxis(int setter); + + public native @Cast("char") byte m_padding(int i); public native btCylinderShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_CYLINDER_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btConeShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONE_MINKOWSKI_H +// #define BT_CONE_MINKOWSKI_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +/**The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y axis. The btConeShapeX is aligned around the X axis and btConeShapeZ around the Z axis. */ +@NoOffset public static class btConeShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeShape(Pointer p) { super(p); } + + + public btConeShape(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native @Cast("btScalar") float getRadius(); + public native @Cast("btScalar") float getHeight(); + + public native void setRadius(@Cast("const btScalar") float radius); + public native void setHeight(@Cast("const btScalar") float height); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("const char*") BytePointer getName(); + + /**choose upAxis index */ + public native void setConeUpIndex(int upIndex); + + public native int getConeUpIndex(); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +/**btConeShape implements a Cone shape, around the X axis */ +public static class btConeShapeX extends btConeShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeShapeX(Pointer p) { super(p); } + + public btConeShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} + +/**btConeShapeZ implements a Cone shape, around the Z axis */ +public static class btConeShapeZ extends btConeShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeShapeZ(Pointer p) { super(p); } + + public btConeShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btConeShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConeShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConeShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConeShapeData position(long position) { + return (btConeShapeData)super.position(position); + } + @Override public btConeShapeData getPointer(long i) { + return new btConeShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btConeShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native int m_upIndex(); public native btConeShapeData m_upIndex(int setter); + + public native @Cast("char") byte m_padding(int i); public native btConeShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_CONE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btConcaveShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONCAVE_SHAPE_H +// #define BT_CONCAVE_SHAPE_H + +// #include "btCollisionShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "btTriangleCallback.h" + +/** PHY_ScalarType enumerates possible scalar types. + * See the btStridingMeshInterface or btHeightfieldTerrainShape for its use */ +/** enum PHY_ScalarType */ +public static final int + PHY_FLOAT = 0, + PHY_DOUBLE = 1, + PHY_INTEGER = 2, + PHY_SHORT = 3, + PHY_FIXEDPOINT88 = 4, + PHY_UCHAR = 5; + +/**The btConcaveShape class provides an interface for non-moving (static) concave shapes. + * It has been implemented by the btStaticPlaneShape, btBvhTriangleMeshShape and btHeightfieldTerrainShape. */ +@NoOffset public static class btConcaveShape extends btCollisionShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConcaveShape(Pointer p) { super(p); } + + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native @Cast("btScalar") float getMargin(); + public native void setMargin(@Cast("btScalar") float collisionMargin); +} + +// #endif //BT_CONCAVE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleCallback.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_CALLBACK_H +// #define BT_TRIANGLE_CALLBACK_H + +// #include "LinearMath/btVector3.h" + +/**The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTriangles. + * This callback is called by processAllTriangles for all btConcaveShape derived class, such as btBvhTriangleMeshShape, btStaticPlaneShape and btHeightfieldTerrainShape. */ +public static class btTriangleCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleCallback(Pointer p) { super(p); } + + public native void processTriangle(btVector3 triangle, int partId, int triangleIndex); +} + +public static class btInternalTriangleIndexCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btInternalTriangleIndexCallback(Pointer p) { super(p); } + + public native void internalProcessTriangleIndex(btVector3 triangle, int partId, int triangleIndex); +} + +// #endif //BT_TRIANGLE_CALLBACK_H + + +// Parsed from BulletCollision/CollisionShapes/btStaticPlaneShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_STATIC_PLANE_SHAPE_H +// #define BT_STATIC_PLANE_SHAPE_H + +// #include "btConcaveShape.h" + +/**The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. */ +@NoOffset public static class btStaticPlaneShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStaticPlaneShape(Pointer p) { super(p); } + + + public btStaticPlaneShape(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConstant) { super((Pointer)null); allocate(planeNormal, planeConstant); } + private native void allocate(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConstant); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native @Const @ByRef btVector3 getPlaneNormal(); + + public native @Cast("const btScalar") float getPlaneConstant(); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btStaticPlaneShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btStaticPlaneShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btStaticPlaneShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStaticPlaneShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btStaticPlaneShapeData position(long position) { + return (btStaticPlaneShapeData)super.position(position); + } + @Override public btStaticPlaneShapeData getPointer(long i) { + return new btStaticPlaneShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btStaticPlaneShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native @ByRef btVector3FloatData m_localScaling(); public native btStaticPlaneShapeData m_localScaling(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_planeNormal(); public native btStaticPlaneShapeData m_planeNormal(btVector3FloatData setter); + public native float m_planeConstant(); public native btStaticPlaneShapeData m_planeConstant(float setter); + public native @Cast("char") byte m_pad(int i); public native btStaticPlaneShapeData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_STATIC_PLANE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexHullShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_HULL_SHAPE_H +// #define BT_CONVEX_HULL_SHAPE_H + +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btAlignedObjectArray.h" + +/**The btConvexHullShape implements an implicit convex hull of an array of vertices. + * Bullet provides a general and fast collision detector for convex shapes based on GJK and EPA using localGetSupportingVertex. */ +@NoOffset public static class btConvexHullShape extends btPolyhedralConvexAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexHullShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexHullShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btConvexHullShape position(long position) { + return (btConvexHullShape)super.position(position); + } + @Override public btConvexHullShape getPointer(long i) { + return new btConvexHullShape((Pointer)this).offsetAddress(i); + } + + + /**this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive btScalar (x,y,z), the striding defines the number of bytes between each point, in memory. + * It is easier to not pass any points in the constructor, and just add one point at a time, using addPoint. + * btConvexHullShape make an internal copy of the points. */ + public btConvexHullShape(@Cast("const btScalar*") FloatPointer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } + private native void allocate(@Cast("const btScalar*") FloatPointer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); + public btConvexHullShape() { super((Pointer)null); allocate(); } + private native void allocate(); + public btConvexHullShape(@Cast("const btScalar*") FloatBuffer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } + private native void allocate(@Cast("const btScalar*") FloatBuffer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); + public btConvexHullShape(@Cast("const btScalar*") float[] points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } + private native void allocate(@Cast("const btScalar*") float[] points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); + + public native void addPoint(@Const @ByRef btVector3 point, @Cast("bool") boolean recalculateLocalAabb/*=true*/); + public native void addPoint(@Const @ByRef btVector3 point); + + public native btVector3 getUnscaledPoints(); + + /**getPoints is obsolete, please use getUnscaledPoints */ + public native @Const btVector3 getPoints(); + + public native void optimizeConvexHull(); + + public native @ByVal btVector3 getScaledPoint(int i); + + public native int getNumPoints(); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatPointer minProj, @Cast("btScalar*") @ByRef FloatPointer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatBuffer minProj, @Cast("btScalar*") @ByRef FloatBuffer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef float[] minProj, @Cast("btScalar*") @ByRef float[] maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumVertices(); + public native int getNumEdges(); + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + public native void getVertex(int i, @ByRef btVector3 vtx); + public native int getNumPlanes(); + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + /**in case we receive negative scaling */ + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btConvexHullShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConvexHullShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexHullShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexHullShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConvexHullShapeData position(long position) { + return (btConvexHullShapeData)super.position(position); + } + @Override public btConvexHullShapeData getPointer(long i) { + return new btConvexHullShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btConvexHullShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native btVector3FloatData m_unscaledPointsFloatPtr(); public native btConvexHullShapeData m_unscaledPointsFloatPtr(btVector3FloatData setter); + public native btVector3DoubleData m_unscaledPointsDoublePtr(); public native btConvexHullShapeData m_unscaledPointsDoublePtr(btVector3DoubleData setter); + + public native int m_numUnscaledPoints(); public native btConvexHullShapeData m_numUnscaledPoints(int setter); + public native @Cast("char") byte m_padding3(int i); public native btConvexHullShapeData m_padding3(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding3(); + +} + +// clang-format on + + + +// #endif //BT_CONVEX_HULL_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btStridingMeshInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_STRIDING_MESHINTERFACE_H +// #define BT_STRIDING_MESHINTERFACE_H + +// #include "LinearMath/btVector3.h" +// #include "btTriangleCallback.h" +// #include "btConcaveShape.h" + +/** The btStridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with btBvhTriangleMeshShape and some other collision shapes. + * Using index striding of 3*sizeof(integer) it can use triangle arrays, using index striding of 1*sizeof(integer) it can handle triangle strips. + * It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory. */ +@NoOffset public static class btStridingMeshInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStridingMeshInterface(Pointer p) { super(p); } + + + public native void InternalProcessAllTriangles(btInternalTriangleIndexCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + /**brute force method to calculate aabb */ + public native void calculateAabbBruteForce(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /** get read and write access to a subpart of a triangle mesh + * this subpart has a continuous array of vertices and indices + * in this way the mesh can be handled as chunks of memory with striding + * very similar to OpenGL vertexarray support + * make a call to unLockVertexBase when the read and write access is finished */ + public native void getLockedVertexIndexBase(@Cast("unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + /** unLockVertexBase finishes the access to a subpart of the triangle mesh + * make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished */ + public native void unLockVertexBase(int subpart); + + public native void unLockReadOnlyVertexBase(int subpart); + + /** getNumSubParts returns the number of separate subparts + * each subpart has a continuous array of vertices and indices */ + public native int getNumSubParts(); + + public native void preallocateVertices(int numverts); + public native void preallocateIndices(int numindices); + + public native @Cast("bool") boolean hasPremadeAabb(); + public native void setPremadeAabb(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + public native void getPremadeAabb(btVector3 aabbMin, btVector3 aabbMax); + + public native @Const @ByRef btVector3 getScaling(); + public native void setScaling(@Const @ByRef btVector3 scaling); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +public static class btIntIndexData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btIntIndexData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btIntIndexData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIntIndexData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btIntIndexData position(long position) { + return (btIntIndexData)super.position(position); + } + @Override public btIntIndexData getPointer(long i) { + return new btIntIndexData((Pointer)this).offsetAddress(i); + } + + public native int m_value(); public native btIntIndexData m_value(int setter); +} + +public static class btShortIntIndexData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btShortIntIndexData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btShortIntIndexData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btShortIntIndexData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btShortIntIndexData position(long position) { + return (btShortIntIndexData)super.position(position); + } + @Override public btShortIntIndexData getPointer(long i) { + return new btShortIntIndexData((Pointer)this).offsetAddress(i); + } + + public native short m_value(); public native btShortIntIndexData m_value(short setter); + public native @Cast("char") byte m_pad(int i); public native btShortIntIndexData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} + +public static class btShortIntIndexTripletData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btShortIntIndexTripletData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btShortIntIndexTripletData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btShortIntIndexTripletData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btShortIntIndexTripletData position(long position) { + return (btShortIntIndexTripletData)super.position(position); + } + @Override public btShortIntIndexTripletData getPointer(long i) { + return new btShortIntIndexTripletData((Pointer)this).offsetAddress(i); + } + + public native short m_values(int i); public native btShortIntIndexTripletData m_values(int i, short setter); + @MemberGetter public native ShortPointer m_values(); + public native @Cast("char") byte m_pad(int i); public native btShortIntIndexTripletData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} + +public static class btCharIndexTripletData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCharIndexTripletData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCharIndexTripletData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCharIndexTripletData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCharIndexTripletData position(long position) { + return (btCharIndexTripletData)super.position(position); + } + @Override public btCharIndexTripletData getPointer(long i) { + return new btCharIndexTripletData((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned char") byte m_values(int i); public native btCharIndexTripletData m_values(int i, byte setter); + @MemberGetter public native @Cast("unsigned char*") BytePointer m_values(); + public native @Cast("char") byte m_pad(); public native btCharIndexTripletData m_pad(byte setter); +} + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btMeshPartData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMeshPartData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMeshPartData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMeshPartData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMeshPartData position(long position) { + return (btMeshPartData)super.position(position); + } + @Override public btMeshPartData getPointer(long i) { + return new btMeshPartData((Pointer)this).offsetAddress(i); + } + + public native btVector3FloatData m_vertices3f(); public native btMeshPartData m_vertices3f(btVector3FloatData setter); + public native btVector3DoubleData m_vertices3d(); public native btMeshPartData m_vertices3d(btVector3DoubleData setter); + + public native btIntIndexData m_indices32(); public native btMeshPartData m_indices32(btIntIndexData setter); + public native btShortIntIndexTripletData m_3indices16(); public native btMeshPartData m_3indices16(btShortIntIndexTripletData setter); + public native btCharIndexTripletData m_3indices8(); public native btMeshPartData m_3indices8(btCharIndexTripletData setter); + + public native btShortIntIndexData m_indices16(); public native btMeshPartData m_indices16(btShortIntIndexData setter);//backwards compatibility + + public native int m_numTriangles(); public native btMeshPartData m_numTriangles(int setter);//length of m_indices = m_numTriangles + public native int m_numVertices(); public native btMeshPartData m_numVertices(int setter); +} + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btStridingMeshInterfaceData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btStridingMeshInterfaceData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btStridingMeshInterfaceData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStridingMeshInterfaceData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btStridingMeshInterfaceData position(long position) { + return (btStridingMeshInterfaceData)super.position(position); + } + @Override public btStridingMeshInterfaceData getPointer(long i) { + return new btStridingMeshInterfaceData((Pointer)this).offsetAddress(i); + } + + public native btMeshPartData m_meshPartsPtr(); public native btStridingMeshInterfaceData m_meshPartsPtr(btMeshPartData setter); + public native @ByRef btVector3FloatData m_scaling(); public native btStridingMeshInterfaceData m_scaling(btVector3FloatData setter); + public native int m_numMeshParts(); public native btStridingMeshInterfaceData m_numMeshParts(int setter); + public native @Cast("char") byte m_padding(int i); public native btStridingMeshInterfaceData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + +// clang-format on + + + +// #endif //BT_STRIDING_MESHINTERFACE_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H +// #define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H + +// #include "btStridingMeshInterface.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btScalar.h" + +/**The btIndexedMesh indexes a single vertex and index array. Multiple btIndexedMesh objects can be passed into a btTriangleIndexVertexArray using addIndexedMesh. + * Instead of the number of indices, we pass the number of triangles. */ +@NoOffset public static class btIndexedMesh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIndexedMesh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btIndexedMesh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btIndexedMesh position(long position) { + return (btIndexedMesh)super.position(position); + } + @Override public btIndexedMesh getPointer(long i) { + return new btIndexedMesh((Pointer)this).offsetAddress(i); + } + + + public native int m_numTriangles(); public native btIndexedMesh m_numTriangles(int setter); + public native @Cast("const unsigned char*") BytePointer m_triangleIndexBase(); public native btIndexedMesh m_triangleIndexBase(BytePointer setter); + // Size in byte of the indices for one triangle (3*sizeof(index_type) if the indices are tightly packed) + public native int m_triangleIndexStride(); public native btIndexedMesh m_triangleIndexStride(int setter); + public native int m_numVertices(); public native btIndexedMesh m_numVertices(int setter); + public native @Cast("const unsigned char*") BytePointer m_vertexBase(); public native btIndexedMesh m_vertexBase(BytePointer setter); + // Size of a vertex, in bytes + public native int m_vertexStride(); public native btIndexedMesh m_vertexStride(int setter); + + // The index type is set when adding an indexed mesh to the + // btTriangleIndexVertexArray, do not set it manually + public native @Cast("PHY_ScalarType") int m_indexType(); public native btIndexedMesh m_indexType(int setter); + + // The vertex type has a default type similar to Bullet's precision mode (float or double) + // but can be set manually if you for example run Bullet with double precision but have + // mesh data in single precision.. + public native @Cast("PHY_ScalarType") int m_vertexType(); public native btIndexedMesh m_vertexType(int setter); + + public btIndexedMesh() { super((Pointer)null); allocate(); } + private native void allocate(); +} + +/**The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays. + * Additional meshes can be added using addIndexedMesh + * No duplicate is made of the vertex/index data, it only indexes into external vertex/index arrays. + * So keep those arrays around during the lifetime of this btTriangleIndexVertexArray. */ +@NoOffset public static class btTriangleIndexVertexArray extends btStridingMeshInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleIndexVertexArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleIndexVertexArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleIndexVertexArray position(long position) { + return (btTriangleIndexVertexArray)super.position(position); + } + @Override public btTriangleIndexVertexArray getPointer(long i) { + return new btTriangleIndexVertexArray((Pointer)this).offsetAddress(i); + } + + + public btTriangleIndexVertexArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + //just to be backwards compatible + public btTriangleIndexVertexArray(int numTriangles, IntPointer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatPointer vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, IntPointer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatPointer vertexBase, int vertexStride); + public btTriangleIndexVertexArray(int numTriangles, IntBuffer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatBuffer vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, IntBuffer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatBuffer vertexBase, int vertexStride); + public btTriangleIndexVertexArray(int numTriangles, int[] triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") float[] vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, int[] triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") float[] vertexBase, int vertexStride); + + public native void addIndexedMesh(@Const @ByRef btIndexedMesh mesh, @Cast("PHY_ScalarType") int indexType/*=PHY_INTEGER*/); + public native void addIndexedMesh(@Const @ByRef btIndexedMesh mesh); + + public native void getLockedVertexIndexBase(@Cast("unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + /** unLockVertexBase finishes the access to a subpart of the triangle mesh + * make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished */ + public native void unLockVertexBase(int subpart); + + public native void unLockReadOnlyVertexBase(int subpart); + + /** getNumSubParts returns the number of separate subparts + * each subpart has a continuous array of vertices and indices */ + public native int getNumSubParts(); + + public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btVector3 getIndexedMeshArray(); + + public native void preallocateVertices(int numverts); + public native void preallocateIndices(int numindices); + + public native @Cast("bool") boolean hasPremadeAabb(); + public native void setPremadeAabb(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + public native void getPremadeAabb(btVector3 aabbMin, btVector3 aabbMax); +} + +// #endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleMesh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_MESH_H +// #define BT_TRIANGLE_MESH_H + +// #include "btTriangleIndexVertexArray.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedObjectArray.h" + +/**The btTriangleMesh class is a convenience class derived from btTriangleIndexVertexArray, that provides storage for a concave triangle mesh. It can be used as data for the btBvhTriangleMeshShape. + * It allows either 32bit or 16bit indices, and 4 (x-y-z-w) or 3 (x-y-z) component vertices. + * If you want to share triangle/index data between graphics mesh and collision mesh (btBvhTriangleMeshShape), you can directly use btTriangleIndexVertexArray or derive your own class from btStridingMeshInterface. + * Performance of btTriangleMesh and btTriangleIndexVertexArray used in a btBvhTriangleMeshShape is the same. */ +@NoOffset public static class btTriangleMesh extends btTriangleIndexVertexArray { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleMesh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleMesh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleMesh position(long position) { + return (btTriangleMesh)super.position(position); + } + @Override public btTriangleMesh getPointer(long i) { + return new btTriangleMesh((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_weldingThreshold(); public native btTriangleMesh m_weldingThreshold(float setter); + + public btTriangleMesh(@Cast("bool") boolean use32bitIndices/*=true*/, @Cast("bool") boolean use4componentVertices/*=true*/) { super((Pointer)null); allocate(use32bitIndices, use4componentVertices); } + private native void allocate(@Cast("bool") boolean use32bitIndices/*=true*/, @Cast("bool") boolean use4componentVertices/*=true*/); + public btTriangleMesh() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean getUse32bitIndices(); + + public native @Cast("bool") boolean getUse4componentVertices(); + /**By default addTriangle won't search for duplicate vertices, because the search is very slow for large triangle meshes. + * In general it is better to directly use btTriangleIndexVertexArray instead. */ + public native void addTriangle(@Const @ByRef btVector3 vertex0, @Const @ByRef btVector3 vertex1, @Const @ByRef btVector3 vertex2, @Cast("bool") boolean removeDuplicateVertices/*=false*/); + public native void addTriangle(@Const @ByRef btVector3 vertex0, @Const @ByRef btVector3 vertex1, @Const @ByRef btVector3 vertex2); + + /**Add a triangle using its indices. Make sure the indices are pointing within the vertices array, so add the vertices first (and to be sure, avoid removal of duplicate vertices) */ + public native void addTriangleIndices(int index1, int index2, int index3); + + public native int getNumTriangles(); + + public native void preallocateVertices(int numverts); + public native void preallocateIndices(int numindices); + + /**findOrAddVertex is an internal method, use addTriangle instead */ + public native int findOrAddVertex(@Const @ByRef btVector3 vertex, @Cast("bool") boolean removeDuplicateVertices); + /**addIndex is an internal method, use addTriangle instead */ + public native void addIndex(int index); +} + +// #endif //BT_TRIANGLE_MESH_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H +// #define BT_CONVEX_TRIANGLEMESH_SHAPE_H + +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +/** The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as btConvexHullShape. + * A small benefit of this class is that it uses the btStridingMeshInterface, so you can avoid the duplication of the triangle mesh data. Nevertheless, most users should use the much better performing btConvexHullShape instead. */ +@NoOffset public static class btConvexTriangleMeshShape extends btPolyhedralConvexAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexTriangleMeshShape(Pointer p) { super(p); } + + + public btConvexTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean calcAabb/*=true*/) { super((Pointer)null); allocate(meshInterface, calcAabb); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean calcAabb/*=true*/); + public btConvexTriangleMeshShape(btStridingMeshInterface meshInterface) { super((Pointer)null); allocate(meshInterface); } + private native void allocate(btStridingMeshInterface meshInterface); + + public native btStridingMeshInterface getMeshInterface(); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumVertices(); + public native int getNumEdges(); + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + public native void getVertex(int i, @ByRef btVector3 vtx); + public native int getNumPlanes(); + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + /**computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia + * and the center of mass to the current coordinate system. A mass of 1 is assumed, for other masses just multiply the computed "inertia" + * by the mass. The resulting transform "principal" has to be applied inversely to the mesh in order for the local coordinate system of the + * shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform + * of the collision object by the principal transform. This method also computes the volume of the convex mesh. */ + public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef FloatPointer volume); + public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef FloatBuffer volume); + public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef float[] volume); +} + +// #endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_MESH_SHAPE_H +// #define BT_TRIANGLE_MESH_SHAPE_H + +// #include "btConcaveShape.h" +// #include "btStridingMeshInterface.h" + +/**The btTriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly, use btBvhTriangleMeshShape instead. */ +@NoOffset public static class btTriangleMeshShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleMeshShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void recalcLocalAabb(); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native btStridingMeshInterface getMeshInterface(); + + public native @Const @ByRef btVector3 getLocalAabbMin(); + public native @Const @ByRef btVector3 getLocalAabbMax(); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} + +// #endif //BT_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btOptimizedBvh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**Contains contributions from Disney Studio's */ + +// #ifndef BT_OPTIMIZED_BVH_H +// #define BT_OPTIMIZED_BVH_H + +// #include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" + +/**The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes, through the btStridingMeshInterface. */ +public static class btOptimizedBvh extends btQuantizedBvh { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOptimizedBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btOptimizedBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btOptimizedBvh position(long position) { + return (btOptimizedBvh)super.position(position); + } + @Override public btOptimizedBvh getPointer(long i) { + return new btOptimizedBvh((Pointer)this).offsetAddress(i); + } + + public btOptimizedBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void build(btStridingMeshInterface triangles, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); + + public native void refit(btStridingMeshInterface triangles, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void refitPartial(btStridingMeshInterface triangles, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void updateBvhNodes(btStridingMeshInterface meshInterface, int firstNode, int endNode, int index); + + /** Data buffer MUST be 16 byte aligned */ + public native @Cast("bool") boolean serializeInPlace(Pointer o_alignedDataBuffer, @Cast("unsigned") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + /**deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' */ + public static native btOptimizedBvh deSerializeInPlace(Pointer i_alignedDataBuffer, @Cast("unsigned int") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); +} + +// #endif //BT_OPTIMIZED_BVH_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleInfoMap.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2010 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef _BT_TRIANGLE_INFO_MAP_H +// #define _BT_TRIANGLE_INFO_MAP_H + +// #include "LinearMath/btHashMap.h" +// #include "LinearMath/btSerializer.h" + +/**for btTriangleInfo m_flags */ +public static final int TRI_INFO_V0V1_CONVEX = 1; +public static final int TRI_INFO_V1V2_CONVEX = 2; +public static final int TRI_INFO_V2V0_CONVEX = 4; + +public static final int TRI_INFO_V0V1_SWAP_NORMALB = 8; +public static final int TRI_INFO_V1V2_SWAP_NORMALB = 16; +public static final int TRI_INFO_V2V0_SWAP_NORMALB = 32; + +/**The btTriangleInfo structure stores information to adjust collision normals to avoid collisions against internal edges + * it can be generated using */ +@NoOffset public static class btTriangleInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleInfo position(long position) { + return (btTriangleInfo)super.position(position); + } + @Override public btTriangleInfo getPointer(long i) { + return new btTriangleInfo((Pointer)this).offsetAddress(i); + } + + public btTriangleInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native int m_flags(); public native btTriangleInfo m_flags(int setter); + + public native @Cast("btScalar") float m_edgeV0V1Angle(); public native btTriangleInfo m_edgeV0V1Angle(float setter); + public native @Cast("btScalar") float m_edgeV1V2Angle(); public native btTriangleInfo m_edgeV1V2Angle(float setter); + public native @Cast("btScalar") float m_edgeV2V0Angle(); public native btTriangleInfo m_edgeV2V0Angle(float setter); +} + +/**The btTriangleInfoMap stores edge angle information for some triangles. You can compute this information yourself or using btGenerateInternalEdgeInfo. */ +@NoOffset public static class btTriangleInfoMap extends btHashMap_btHashPtr_voidPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleInfoMap(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleInfoMap(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleInfoMap position(long position) { + return (btTriangleInfoMap)super.position(position); + } + @Override public btTriangleInfoMap getPointer(long i) { + return new btTriangleInfoMap((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_convexEpsilon(); public native btTriangleInfoMap m_convexEpsilon(float setter); /**used to determine if an edge or contact normal is convex, using the dot product */ + public native @Cast("btScalar") float m_planarEpsilon(); public native btTriangleInfoMap m_planarEpsilon(float setter); /**used to determine if a triangle edge is planar with zero angle */ + public native @Cast("btScalar") float m_equalVertexThreshold(); public native btTriangleInfoMap m_equalVertexThreshold(float setter); /**used to compute connectivity: if the distance between two vertices is smaller than m_equalVertexThreshold, they are considered to be 'shared' */ + public native @Cast("btScalar") float m_edgeDistanceThreshold(); public native btTriangleInfoMap m_edgeDistanceThreshold(float setter); /**used to determine edge contacts: if the closest distance between a contact point and an edge is smaller than this distance threshold it is considered to "hit the edge" */ + public native @Cast("btScalar") float m_maxEdgeAngleThreshold(); public native btTriangleInfoMap m_maxEdgeAngleThreshold(float setter); //ignore edges that connect triangles at an angle larger than this m_maxEdgeAngleThreshold + public native @Cast("btScalar") float m_zeroAreaThreshold(); public native btTriangleInfoMap m_zeroAreaThreshold(float setter); /**used to determine if a triangle is degenerate (length squared of cross product of 2 triangle edges < threshold) */ + + public btTriangleInfoMap() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void deSerialize(@ByRef btTriangleInfoMapData data); +} + +// clang-format off + +/**those fields have to be float and not btScalar for the serialization to work properly */ +public static class btTriangleInfoData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTriangleInfoData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleInfoData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleInfoData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTriangleInfoData position(long position) { + return (btTriangleInfoData)super.position(position); + } + @Override public btTriangleInfoData getPointer(long i) { + return new btTriangleInfoData((Pointer)this).offsetAddress(i); + } + + public native int m_flags(); public native btTriangleInfoData m_flags(int setter); + public native float m_edgeV0V1Angle(); public native btTriangleInfoData m_edgeV0V1Angle(float setter); + public native float m_edgeV1V2Angle(); public native btTriangleInfoData m_edgeV1V2Angle(float setter); + public native float m_edgeV2V0Angle(); public native btTriangleInfoData m_edgeV2V0Angle(float setter); +} + +public static class btTriangleInfoMapData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTriangleInfoMapData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleInfoMapData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleInfoMapData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTriangleInfoMapData position(long position) { + return (btTriangleInfoMapData)super.position(position); + } + @Override public btTriangleInfoMapData getPointer(long i) { + return new btTriangleInfoMapData((Pointer)this).offsetAddress(i); + } + + public native IntPointer m_hashTablePtr(); public native btTriangleInfoMapData m_hashTablePtr(IntPointer setter); + public native IntPointer m_nextPtr(); public native btTriangleInfoMapData m_nextPtr(IntPointer setter); + public native btTriangleInfoData m_valueArrayPtr(); public native btTriangleInfoMapData m_valueArrayPtr(btTriangleInfoData setter); + public native IntPointer m_keyArrayPtr(); public native btTriangleInfoMapData m_keyArrayPtr(IntPointer setter); + + public native float m_convexEpsilon(); public native btTriangleInfoMapData m_convexEpsilon(float setter); + public native float m_planarEpsilon(); public native btTriangleInfoMapData m_planarEpsilon(float setter); + public native float m_equalVertexThreshold(); public native btTriangleInfoMapData m_equalVertexThreshold(float setter); + public native float m_edgeDistanceThreshold(); public native btTriangleInfoMapData m_edgeDistanceThreshold(float setter); + public native float m_zeroAreaThreshold(); public native btTriangleInfoMapData m_zeroAreaThreshold(float setter); + + public native int m_nextSize(); public native btTriangleInfoMapData m_nextSize(int setter); + public native int m_hashTableSize(); public native btTriangleInfoMapData m_hashTableSize(int setter); + public native int m_numValues(); public native btTriangleInfoMapData m_numValues(int setter); + public native int m_numKeys(); public native btTriangleInfoMapData m_numKeys(int setter); + public native @Cast("char") byte m_padding(int i); public native btTriangleInfoMapData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + +// clang-format on + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //_BT_TRIANGLE_INFO_MAP_H + + +// Parsed from BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H +// #define BT_BVH_TRIANGLE_MESH_SHAPE_H + +// #include "btTriangleMeshShape.h" +// #include "btOptimizedBvh.h" +// #include "LinearMath/btAlignedAllocator.h" +// #include "btTriangleInfoMap.h" + +/**The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving objects. + * If you required moving concave triangle meshes, it is recommended to perform convex decomposition + * using HACD, see Bullet/Demos/ConvexDecompositionDemo. + * Alternatively, you can use btGimpactMeshShape for moving concave triangle meshes. + * btBvhTriangleMeshShape has several optimizations, such as bounding volume hierarchy and + * cache friendly traversal for PlayStation 3 Cell SPU. + * It is recommended to enable useQuantizedAabbCompression for better memory usage. + * It takes a triangle mesh as input, for example a btTriangleMesh or btTriangleIndexVertexArray. The btBvhTriangleMeshShape class allows for triangle mesh deformations by a refit or partialRefit method. + * Instead of building the bounding volume hierarchy acceleration structure, it is also possible to serialize (save) and deserialize (load) the structure from disk. + * See Demos\ConcaveDemo\ConcavePhysicsDemo.cpp for an example. */ +@NoOffset public static class btBvhTriangleMeshShape extends btTriangleMeshShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBvhTriangleMeshShape(Pointer p) { super(p); } + + + public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Cast("bool") boolean buildBvh/*=true*/) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, buildBvh); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Cast("bool") boolean buildBvh/*=true*/); + public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression); + + /**optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb */ + public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("bool") boolean buildBvh/*=true*/) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax, buildBvh); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("bool") boolean buildBvh/*=true*/); + public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); + + public native @Cast("bool") boolean getOwnsBvh(); + + public native void performRaycast(btTriangleCallback callback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget); + public native void performConvexcast(btTriangleCallback callback, @Const @ByRef btVector3 boxSource, @Const @ByRef btVector3 boxTarget, @Const @ByRef btVector3 boxMin, @Const @ByRef btVector3 boxMax); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void refitTree(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + /**for a fast incremental refit of parts of the tree. Note: the entire AABB of the tree will become more conservative, it never shrinks */ + public native void partialRefitTree(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native btOptimizedBvh getOptimizedBvh(); + + public native void setOptimizedBvh(btOptimizedBvh bvh, @Const @ByRef(nullValue = "btVector3(1, 1, 1)") btVector3 localScaling); + public native void setOptimizedBvh(btOptimizedBvh bvh); + + public native void buildOptimizedBvh(); + + public native @Cast("bool") boolean usesQuantizedAabbCompression(); + + public native void setTriangleInfoMap(btTriangleInfoMap triangleInfoMap); + + public native btTriangleInfoMap getTriangleInfoMap(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void serializeSingleBvh(btSerializer serializer); + + public native void serializeSingleTriangleInfoMap(btSerializer serializer); +} + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btTriangleMeshShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTriangleMeshShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleMeshShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleMeshShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTriangleMeshShapeData position(long position) { + return (btTriangleMeshShapeData)super.position(position); + } + @Override public btTriangleMeshShapeData getPointer(long i) { + return new btTriangleMeshShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btTriangleMeshShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native @ByRef btStridingMeshInterfaceData m_meshInterface(); public native btTriangleMeshShapeData m_meshInterface(btStridingMeshInterfaceData setter); + + public native btQuantizedBvhFloatData m_quantizedFloatBvh(); public native btTriangleMeshShapeData m_quantizedFloatBvh(btQuantizedBvhFloatData setter); + public native btQuantizedBvhDoubleData m_quantizedDoubleBvh(); public native btTriangleMeshShapeData m_quantizedDoubleBvh(btQuantizedBvhDoubleData setter); + + public native btTriangleInfoMapData m_triangleInfoMap(); public native btTriangleMeshShapeData m_triangleInfoMap(btTriangleInfoMapData setter); + + public native float m_collisionMargin(); public native btTriangleMeshShapeData m_collisionMargin(float setter); + + public native @Cast("char") byte m_pad3(int i); public native btTriangleMeshShapeData m_pad3(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad3(); + +} + +// clang-format on + + + +// #endif //BT_BVH_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +// #define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H + +// #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" + +/**The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMeshShape. + * Note that each btBvhTriangleMeshShape still can have its own local scaling, independent from this btScaledBvhTriangleMeshShape 'localScaling' */ +@NoOffset public static class btScaledBvhTriangleMeshShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btScaledBvhTriangleMeshShape(Pointer p) { super(p); } + + + public btScaledBvhTriangleMeshShape(btBvhTriangleMeshShape childShape, @Const @ByRef btVector3 localScaling) { super((Pointer)null); allocate(childShape, localScaling); } + private native void allocate(btBvhTriangleMeshShape childShape, @Const @ByRef btVector3 localScaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native btBvhTriangleMeshShape getChildShape(); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btScaledTriangleMeshShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btScaledTriangleMeshShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btScaledTriangleMeshShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btScaledTriangleMeshShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btScaledTriangleMeshShapeData position(long position) { + return (btScaledTriangleMeshShapeData)super.position(position); + } + @Override public btScaledTriangleMeshShapeData getPointer(long i) { + return new btScaledTriangleMeshShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btTriangleMeshShapeData m_trimeshShapeData(); public native btScaledTriangleMeshShapeData m_trimeshShapeData(btTriangleMeshShapeData setter); + + public native @ByRef btVector3FloatData m_localScaling(); public native btScaledTriangleMeshShapeData m_localScaling(btVector3FloatData setter); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btCompoundShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COMPOUND_SHAPE_H +// #define BT_COMPOUND_SHAPE_H + +// #include "btCollisionShape.h" + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// #include "LinearMath/btAlignedObjectArray.h" + +//class btOptimizedBvh; +@Opaque public static class btDbvt extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btDbvt() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvt(Pointer p) { super(p); } +} + +public static class btCompoundShapeChild extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCompoundShapeChild() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundShapeChild(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundShapeChild(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCompoundShapeChild position(long position) { + return (btCompoundShapeChild)super.position(position); + } + @Override public btCompoundShapeChild getPointer(long i) { + return new btCompoundShapeChild((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransform m_transform(); public native btCompoundShapeChild m_transform(btTransform setter); + public native btCollisionShape m_childShape(); public native btCompoundShapeChild m_childShape(btCollisionShape setter); + public native int m_childShapeType(); public native btCompoundShapeChild m_childShapeType(int setter); + public native @Cast("btScalar") float m_childMargin(); public native btCompoundShapeChild m_childMargin(float setter); + +} + +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btCompoundShapeChild c1, @Const @ByRef btCompoundShapeChild c2); + +/** The btCompoundShape allows to store multiple other btCollisionShapes + * This allows for moving concave collision objects. This is more general then the static concave btBvhTriangleMeshShape. + * It has an (optional) dynamic aabb tree to accelerate early rejection tests. + * \todo: This aabb tree can also be use to speed up ray tests on btCompoundShape, see http://code.google.com/p/bullet/issues/detail?id=25 + * Currently, removal of child shapes is only supported when disabling the aabb tree (pass 'false' in the constructor of btCompoundShape) */ +@NoOffset public static class btCompoundShape extends btCollisionShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCompoundShape position(long position) { + return (btCompoundShape)super.position(position); + } + @Override public btCompoundShape getPointer(long i) { + return new btCompoundShape((Pointer)this).offsetAddress(i); + } + + + public btCompoundShape(@Cast("bool") boolean enableDynamicAabbTree/*=true*/, int initialChildCapacity/*=0*/) { super((Pointer)null); allocate(enableDynamicAabbTree, initialChildCapacity); } + private native void allocate(@Cast("bool") boolean enableDynamicAabbTree/*=true*/, int initialChildCapacity/*=0*/); + public btCompoundShape() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void addChildShape(@Const @ByRef btTransform localTransform, btCollisionShape shape); + + /** Remove all children shapes that contain the specified shape */ + public native void removeChildShape(btCollisionShape shape); + + public native void removeChildShapeByIndex(int childShapeindex); + + public native int getNumChildShapes(); + + public native btCollisionShape getChildShape(int index); + + public native @ByRef btTransform getChildTransform(int index); + + /**set a new transform for a child, and update internal data structures (local aabb and dynamic tree) */ + public native void updateChildTransform(int childIndex, @Const @ByRef btTransform newChildTransform, @Cast("bool") boolean shouldRecalculateLocalAabb/*=true*/); + public native void updateChildTransform(int childIndex, @Const @ByRef btTransform newChildTransform); + + public native btCompoundShapeChild getChildList(); + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /** Re-calculate the local Aabb. Is called at the end of removeChildShapes. + Use this yourself if you modify the children or their transforms. */ + public native void recalculateLocalAabb(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + public native @Cast("const char*") BytePointer getName(); + + public native btDbvt getDynamicAabbTree(); + + public native void createAabbTreeFromChildren(); + + /**computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia + * and the center of mass to the current coordinate system. "masses" points to an array of masses of the children. The resulting transform + * "principal" has to be applied inversely to all children transforms in order for the local coordinate system of the compound + * shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform + * of the collision object by the principal transform. */ + public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") FloatPointer masses, @ByRef btTransform principal, @ByRef btVector3 inertia); + public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") FloatBuffer masses, @ByRef btTransform principal, @ByRef btVector3 inertia); + public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") float[] masses, @ByRef btTransform principal, @ByRef btVector3 inertia); + + public native int getUpdateRevision(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btCompoundShapeChildData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCompoundShapeChildData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundShapeChildData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundShapeChildData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCompoundShapeChildData position(long position) { + return (btCompoundShapeChildData)super.position(position); + } + @Override public btCompoundShapeChildData getPointer(long i) { + return new btCompoundShapeChildData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btTransformFloatData m_transform(); public native btCompoundShapeChildData m_transform(btTransformFloatData setter); + public native btCollisionShapeData m_childShape(); public native btCompoundShapeChildData m_childShape(btCollisionShapeData setter); + public native int m_childShapeType(); public native btCompoundShapeChildData m_childShapeType(int setter); + public native float m_childMargin(); public native btCompoundShapeChildData m_childMargin(float setter); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btCompoundShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCompoundShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCompoundShapeData position(long position) { + return (btCompoundShapeData)super.position(position); + } + @Override public btCompoundShapeData getPointer(long i) { + return new btCompoundShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btCompoundShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native btCompoundShapeChildData m_childShapePtr(); public native btCompoundShapeData m_childShapePtr(btCompoundShapeChildData setter); + + public native int m_numChildShapes(); public native btCompoundShapeData m_numChildShapes(int setter); + + public native float m_collisionMargin(); public native btCompoundShapeData m_collisionMargin(float setter); + +} + +// clang-format on + + + +// #endif //BT_COMPOUND_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btTetrahedronShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMPLEX_1TO4_SHAPE +// #define BT_SIMPLEX_1TO4_SHAPE + +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" + +/**The btBU_Simplex1to4 implements tetrahedron, triangle, line, vertex collision shapes. In most cases it is better to use btConvexHullShape instead. */ +@NoOffset public static class btBU_Simplex1to4 extends btPolyhedralConvexAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBU_Simplex1to4(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBU_Simplex1to4(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBU_Simplex1to4 position(long position) { + return (btBU_Simplex1to4)super.position(position); + } + @Override public btBU_Simplex1to4 getPointer(long i) { + return new btBU_Simplex1to4((Pointer)this).offsetAddress(i); + } + + + public btBU_Simplex1to4() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btBU_Simplex1to4(@Const @ByRef btVector3 pt0) { super((Pointer)null); allocate(pt0); } + private native void allocate(@Const @ByRef btVector3 pt0); + public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1) { super((Pointer)null); allocate(pt0, pt1); } + private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1); + public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2) { super((Pointer)null); allocate(pt0, pt1, pt2); } + private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2); + public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2, @Const @ByRef btVector3 pt3) { super((Pointer)null); allocate(pt0, pt1, pt2, pt3); } + private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2, @Const @ByRef btVector3 pt3); + + public native void reset(); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void addVertex(@Const @ByRef btVector3 pt); + + //PolyhedralConvexShape interface + + public native int getNumVertices(); + + public native int getNumEdges(); + + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + + public native void getVertex(int i, @ByRef btVector3 vtx); + + public native int getNumPlanes(); + + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + + public native int getIndex(int i); + + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + /**getName is for debugging */ + public native @Cast("const char*") BytePointer getName(); +} + +// #endif //BT_SIMPLEX_1TO4_SHAPE + + +// Parsed from BulletCollision/CollisionShapes/btEmptyShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_EMPTY_SHAPE_H +// #define BT_EMPTY_SHAPE_H + +// #include "btConcaveShape.h" + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" + +/** The btEmptyShape is a collision shape without actual collision detection shape, so most users should ignore this class. + * It can be replaced by another shape during runtime, but the inertia tensor should be recomputed. */ +@NoOffset public static class btEmptyShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btEmptyShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btEmptyShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btEmptyShape position(long position) { + return (btEmptyShape)super.position(position); + } + @Override public btEmptyShape getPointer(long i) { + return new btEmptyShape((Pointer)this).offsetAddress(i); + } + + + public btEmptyShape() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("const char*") BytePointer getName(); + + public native void processAllTriangles(btTriangleCallback arg0, @Const @ByRef btVector3 arg1, @Const @ByRef btVector3 arg2); +} + +// #endif //BT_EMPTY_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btMultiSphereShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTI_SPHERE_MINKOWSKI_H +// #define BT_MULTI_SPHERE_MINKOWSKI_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btAabbUtil2.h" + +/**The btMultiSphereShape represents the convex hull of a collection of spheres. You can create special capsules or other smooth volumes. + * It is possible to animate the spheres for deformation, but call 'recalcLocalAabb' after changing any sphere position/radius */ +@NoOffset public static class btMultiSphereShape extends btConvexInternalAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiSphereShape(Pointer p) { super(p); } + + + public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") FloatPointer radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } + private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") FloatPointer radi, int numSpheres); + public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") FloatBuffer radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } + private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") FloatBuffer radi, int numSpheres); + public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") float[] radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } + private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") float[] radi, int numSpheres); + + /**CollisionShape Interface */ + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + /** btConvexShape Interface */ + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native int getSphereCount(); + + public native @Const @ByRef btVector3 getSpherePosition(int index); + + public native @Cast("btScalar") float getSphereRadius(int index); + + public native @Cast("const char*") BytePointer getName(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +public static class btPositionAndRadius extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPositionAndRadius() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPositionAndRadius(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPositionAndRadius(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPositionAndRadius position(long position) { + return (btPositionAndRadius)super.position(position); + } + @Override public btPositionAndRadius getPointer(long i) { + return new btPositionAndRadius((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_pos(); public native btPositionAndRadius m_pos(btVector3FloatData setter); + public native float m_radius(); public native btPositionAndRadius m_radius(float setter); +} + +// clang-format off + +public static class btMultiSphereShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiSphereShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiSphereShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiSphereShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiSphereShapeData position(long position) { + return (btMultiSphereShapeData)super.position(position); + } + @Override public btMultiSphereShapeData getPointer(long i) { + return new btMultiSphereShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btMultiSphereShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native btPositionAndRadius m_localPositionArrayPtr(); public native btMultiSphereShapeData m_localPositionArrayPtr(btPositionAndRadius setter); + public native int m_localPositionArraySize(); public native btMultiSphereShapeData m_localPositionArraySize(int setter); + public native @Cast("char") byte m_padding(int i); public native btMultiSphereShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + +// clang-format on + + + +// #endif //BT_MULTI_SPHERE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btUniformScalingShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_UNIFORM_SCALING_SHAPE_H +// #define BT_UNIFORM_SCALING_SHAPE_H + +// #include "btConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types + +/**The btUniformScalingShape allows to re-use uniform scaled instances of btConvexShape in a memory efficient way. + * Istead of using btUniformScalingShape, it is better to use the non-uniform setLocalScaling method on convex shapes that implement it. */ +@NoOffset public static class btUniformScalingShape extends btConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btUniformScalingShape(Pointer p) { super(p); } + + + public btUniformScalingShape(btConvexShape convexChildShape, @Cast("btScalar") float uniformScalingFactor) { super((Pointer)null); allocate(convexChildShape, uniformScalingFactor); } + private native void allocate(btConvexShape convexChildShape, @Cast("btScalar") float uniformScalingFactor); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("btScalar") float getUniformScalingFactor(); + + public native btConvexShape getChildShape(); + + public native @Cast("const char*") BytePointer getName(); + + /////////////////////////// + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void getAabbSlow(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); +} + +// #endif //BT_UNIFORM_SCALING_SHAPE_H + + +} diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java new file mode 100644 index 00000000000..5da065a4208 --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -0,0 +1,91 @@ +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +@Properties( + inherit = LinearMath.class, + value = { + @Platform( + include = { + "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h", + "BulletCollision/BroadphaseCollision/btDispatcher.h", + "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h", + "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h", + "BulletCollision/BroadphaseCollision/btQuantizedBvh.h", + "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h", + "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h", + "BulletCollision/BroadphaseCollision/btAxisSweep3.h", + "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h", + "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h", + "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h", + "BulletCollision/CollisionDispatch/btCollisionObject.h", + "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h", + "BulletCollision/CollisionDispatch/btCollisionDispatcher.h", + "BulletCollision/CollisionDispatch/btCollisionWorld.h", + "BulletCollision/CollisionDispatch/btManifoldResult.h", + "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h", + "BulletCollision/CollisionShapes/btCollisionShape.h", + "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h", + "BulletCollision/CollisionShapes/btConvexInternalShape.h", + "BulletCollision/CollisionShapes/btBoxShape.h", + "BulletCollision/CollisionShapes/btSphereShape.h", + "BulletCollision/CollisionShapes/btCapsuleShape.h", + "BulletCollision/CollisionShapes/btCylinderShape.h", + "BulletCollision/CollisionShapes/btConeShape.h", + "BulletCollision/CollisionShapes/btConcaveShape.h", + "BulletCollision/CollisionShapes/btTriangleCallback.h", + "BulletCollision/CollisionShapes/btStaticPlaneShape.h", + "BulletCollision/CollisionShapes/btConvexHullShape.h", + "BulletCollision/CollisionShapes/btStridingMeshInterface.h", + "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h", + "BulletCollision/CollisionShapes/btTriangleMesh.h", + "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h", + "BulletCollision/CollisionShapes/btTriangleMeshShape.h", + "BulletCollision/CollisionShapes/btOptimizedBvh.h", + "BulletCollision/CollisionShapes/btTriangleInfoMap.h", + "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h", + "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h", + "BulletCollision/CollisionShapes/btCompoundShape.h", + "BulletCollision/CollisionShapes/btTetrahedronShape.h", + "BulletCollision/CollisionShapes/btEmptyShape.h", + "BulletCollision/CollisionShapes/btMultiSphereShape.h", + "BulletCollision/CollisionShapes/btUniformScalingShape.h", + }, + link = "BulletCollision" + ) + }, + target = "org.bytedeco.bullet.BulletCollision" +) +public class BulletCollision implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + public void map(InfoMap infoMap) { + infoMap + .put(new Info("btCollisionObjectData").cppText("#define btCollisionObjectData btCollisionObjectFloatData")) + .put(new Info( "btOverlappingPairCache::getOverlappingPairArray").skip()) + .put(new Info("btHashedOverlappingPairCache::getOverlappingPairArray").skip()) + .put(new Info("btSortedOverlappingPairCache::getOverlappingPairArray").skip()) + .put(new Info("btNullPairCache::getOverlappingPairArray").skip()) + .put(new Info("btCollisionWorld::AllHitsRayResultCallback::m_collisionObjects").skip()) + .put(new Info("PFX_USE_FREE_VECTORMATH").define(false)) + .put(new Info("__SPU__").define(false)) + .put(new Info("btQuantizedBvhData").cppText("#define btQuantizedBvhData btQuantizedBvhFloatData")) + .put(new Info("btOptimizedBvhNodeData").cppText("#define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData")) + .put(new Info("btCompoundShapeChild::m_node").skip()) + .put(new Info("btSphereSphereCollisionAlgorithm::getAllContactManifolds").skip()) + .put(new Info("btAxisSweep3").base("btBroadphaseInterface")) + .put(new Info("bt32BitAxisSweep3").base("btBroadphaseInterface")) + .put(new Info("btDbvtBroadphase::m_rayTestStacks").skip()) + .put(new Info("btDbvtProxy").skip()) + .put(new Info("DBVT_BP_PROFILE").define(false)) + ; + } +} diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index fa6f7245064..93ef34d1446 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -2,4 +2,5 @@ requires transitive org.bytedeco.javacpp; exports org.bytedeco.bullet.presets; exports org.bytedeco.bullet.LinearMath; + exports org.bytedeco.bullet.BulletCollision; } From fa393201d0ff85a939357559c9286672de203a80 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Feb 2022 19:02:39 +0800 Subject: [PATCH 06/81] Generate bindings for bullet's BulletDynamics library Part of the bullet package. --- .../org/bytedeco/bullet/BulletDynamics.java | 3860 +++++++++++++++++ .../bullet/presets/BulletDynamics.java | 104 + bullet/src/main/java9/module-info.java | 1 + 3 files changed, 3965 insertions(+) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics.java create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics.java new file mode 100644 index 00000000000..8c46999f97c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics.java @@ -0,0 +1,3860 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import static org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.BulletCollision.*; + +public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { + static { Loader.load(); } + +// Parsed from LinearMath/btAlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBJECT_ARRAY__ +// #define BT_OBJECT_ARRAY__ + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +// #include "btAlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW + * then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int BT_USE_PLACEMENT_NEW = 1; +//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef BT_USE_MEMCPY +// #include +// #include +// #endif //BT_USE_MEMCPY + +// #ifdef BT_USE_PLACEMENT_NEW +// #include //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset public static class btAlignedObjectArray_btRigidBodyPointer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btRigidBodyPointer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btRigidBodyPointer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btRigidBodyPointer position(long position) { + return (btAlignedObjectArray_btRigidBodyPointer)super.position(position); + } + @Override public btAlignedObjectArray_btRigidBodyPointer getPointer(long i) { + return new btAlignedObjectArray_btRigidBodyPointer((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btRigidBodyPointer put(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer other); + public btAlignedObjectArray_btRigidBodyPointer() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btRigidBodyPointer(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btRigidBody at(int n); + + public native @ByPtrRef @Name("operator []") btRigidBody get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btRigidBody fillData/*=btRigidBody*()*/); + public native void resize(int newsize); + public native @ByPtrRef btRigidBody expandNonInitializing(); + + public native @ByPtrRef btRigidBody expand(@ByPtrRef btRigidBody fillValue/*=btRigidBody*()*/); + public native @ByPtrRef btRigidBody expand(); + + public native void push_back(@ByPtrRef btRigidBody _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btRigidBody key); + + public native int findLinearSearch(@ByPtrRef btRigidBody key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btRigidBody key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btRigidBody key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); +} + +// #endif //BT_OBJECT_ARRAY__ + + +// Parsed from BulletDynamics/Dynamics/btRigidBody.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_RIGIDBODY_H +// #define BT_RIGIDBODY_H + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btTransform.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +@Opaque public static class btTypedConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btTypedConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTypedConstraint(Pointer p) { super(p); } +} + +public static native @Cast("btScalar") float gDeactivationTime(); public static native void gDeactivationTime(float setter); +public static native @Cast("bool") boolean gDisableDeactivation(); public static native void gDisableDeactivation(boolean setter); + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btRigidBodyData btRigidBodyFloatData +public static final String btRigidBodyDataName = "btRigidBodyFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum btRigidBodyFlags */ +public static final int + BT_DISABLE_WORLD_GRAVITY = 1, + /**BT_ENABLE_GYROPSCOPIC_FORCE flags is enabled by default in Bullet 2.83 and onwards. + * and it BT_ENABLE_GYROPSCOPIC_FORCE becomes equivalent to BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY + * See Demos/GyroscopicDemo and computeGyroscopicImpulseImplicit */ + BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT = 2, + BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD = 4, + BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY = 8, + BT_ENABLE_GYROPSCOPIC_FORCE = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY; + +/**The btRigidBody is the main class for rigid body objects. It is derived from btCollisionObject, so it keeps a pointer to a btCollisionShape. + * It is recommended for performance and memory use to share btCollisionShape objects whenever possible. + * There are 3 types of rigid bodies: + * - A) Dynamic rigid bodies, with positive mass. Motion is controlled by rigid body dynamics. + * - B) Fixed objects with zero mass. They are not moving (basically collision objects) + * - C) Kinematic objects, which are objects without mass, but the user can move them. There is one-way interaction, and Bullet calculates a velocity based on the timestep and previous and current world transform. + * Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time. + * Deactivated (sleeping) rigid bodies don't take any processing time, except a minor broadphase collision detection impact (to allow active objects to activate/wake up sleeping objects) */ +@NoOffset public static class btRigidBody extends btCollisionObject { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBody(Pointer p) { super(p); } + + /**The btRigidBodyConstructionInfo structure provides information to create a rigid body. Setting mass to zero creates a fixed (non-dynamic) rigid body. + * For dynamic objects, you can use the collision shape to approximate the local inertia tensor, otherwise use the zero vector (default argument) + * You can use the motion state to synchronize the world transform between physics and graphics objects. + * And if the motion state is provided, the rigid body will initialize its initial world transform from the motion state, + * m_startWorldTransform is only used when you don't provide a motion state. */ + @NoOffset public static class btRigidBodyConstructionInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBodyConstructionInfo(Pointer p) { super(p); } + + public native @Cast("btScalar") float m_mass(); public native btRigidBodyConstructionInfo m_mass(float setter); + + /**When a motionState is provided, the rigid body will initialize its world transform from the motion state + * In this case, m_startWorldTransform is ignored. */ + public native btMotionState m_motionState(); public native btRigidBodyConstructionInfo m_motionState(btMotionState setter); + public native @ByRef btTransform m_startWorldTransform(); public native btRigidBodyConstructionInfo m_startWorldTransform(btTransform setter); + + public native btCollisionShape m_collisionShape(); public native btRigidBodyConstructionInfo m_collisionShape(btCollisionShape setter); + public native @ByRef btVector3 m_localInertia(); public native btRigidBodyConstructionInfo m_localInertia(btVector3 setter); + public native @Cast("btScalar") float m_linearDamping(); public native btRigidBodyConstructionInfo m_linearDamping(float setter); + public native @Cast("btScalar") float m_angularDamping(); public native btRigidBodyConstructionInfo m_angularDamping(float setter); + + /**best simulation results when friction is non-zero */ + public native @Cast("btScalar") float m_friction(); public native btRigidBodyConstructionInfo m_friction(float setter); + /**the m_rollingFriction prevents rounded shapes, such as spheres, cylinders and capsules from rolling forever. + * See Bullet/Demos/RollingFrictionDemo for usage */ + public native @Cast("btScalar") float m_rollingFriction(); public native btRigidBodyConstructionInfo m_rollingFriction(float setter); + public native @Cast("btScalar") float m_spinningFriction(); public native btRigidBodyConstructionInfo m_spinningFriction(float setter); //torsional friction around contact normal + + /**best simulation results using zero restitution. */ + public native @Cast("btScalar") float m_restitution(); public native btRigidBodyConstructionInfo m_restitution(float setter); + + public native @Cast("btScalar") float m_linearSleepingThreshold(); public native btRigidBodyConstructionInfo m_linearSleepingThreshold(float setter); + public native @Cast("btScalar") float m_angularSleepingThreshold(); public native btRigidBodyConstructionInfo m_angularSleepingThreshold(float setter); + + //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc. + //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete + public native @Cast("bool") boolean m_additionalDamping(); public native btRigidBodyConstructionInfo m_additionalDamping(boolean setter); + public native @Cast("btScalar") float m_additionalDampingFactor(); public native btRigidBodyConstructionInfo m_additionalDampingFactor(float setter); + public native @Cast("btScalar") float m_additionalLinearDampingThresholdSqr(); public native btRigidBodyConstructionInfo m_additionalLinearDampingThresholdSqr(float setter); + public native @Cast("btScalar") float m_additionalAngularDampingThresholdSqr(); public native btRigidBodyConstructionInfo m_additionalAngularDampingThresholdSqr(float setter); + public native @Cast("btScalar") float m_additionalAngularDampingFactor(); public native btRigidBodyConstructionInfo m_additionalAngularDampingFactor(float setter); + + public btRigidBodyConstructionInfo(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia) { super((Pointer)null); allocate(mass, motionState, collisionShape, localInertia); } + private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia); + public btRigidBodyConstructionInfo(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape) { super((Pointer)null); allocate(mass, motionState, collisionShape); } + private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape); + } + + /**btRigidBody constructor using construction info */ + public btRigidBody(@Const @ByRef btRigidBodyConstructionInfo constructionInfo) { super((Pointer)null); allocate(constructionInfo); } + private native void allocate(@Const @ByRef btRigidBodyConstructionInfo constructionInfo); + + /**btRigidBody constructor for backwards compatibility. + * To specify friction (etc) during rigid body construction, please use the other constructor (using btRigidBodyConstructionInfo) */ + public btRigidBody(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia) { super((Pointer)null); allocate(mass, motionState, collisionShape, localInertia); } + private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia); + public btRigidBody(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape) { super((Pointer)null); allocate(mass, motionState, collisionShape); } + private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape); + public native void proceedToTransform(@Const @ByRef btTransform newTrans); + + /**to keep collision detection and dynamics separate we don't store a rigidbody pointer + * but a rigidbody is derived from btCollisionObject, so we can safely perform an upcast */ + public static native @Const btRigidBody upcast(@Const btCollisionObject colObj); + + /** continuous collision detection needs prediction */ + public native void predictIntegratedTransform(@Cast("btScalar") float step, @ByRef btTransform predictedTransform); + + public native void saveKinematicState(@Cast("btScalar") float step); + + public native void applyGravity(); + + public native void clearGravity(); + + public native void setGravity(@Const @ByRef btVector3 acceleration); + + public native @Const @ByRef btVector3 getGravity(); + + public native void setDamping(@Cast("btScalar") float lin_damping, @Cast("btScalar") float ang_damping); + + public native @Cast("btScalar") float getLinearDamping(); + + public native @Cast("btScalar") float getAngularDamping(); + + public native @Cast("btScalar") float getLinearSleepingThreshold(); + + public native @Cast("btScalar") float getAngularSleepingThreshold(); + + public native void applyDamping(@Cast("btScalar") float timeStep); + + public native btCollisionShape getCollisionShape(); + + public native void setMassProps(@Cast("btScalar") float mass, @Const @ByRef btVector3 inertia); + + public native @Const @ByRef btVector3 getLinearFactor(); + public native void setLinearFactor(@Const @ByRef btVector3 linearFactor); + public native @Cast("btScalar") float getInvMass(); + public native @Cast("btScalar") float getMass(); + public native @Const @ByRef btMatrix3x3 getInvInertiaTensorWorld(); + + public native void integrateVelocities(@Cast("btScalar") float step); + + public native void setCenterOfMassTransform(@Const @ByRef btTransform xform); + + public native void applyCentralForce(@Const @ByRef btVector3 force); + + public native @Const @ByRef btVector3 getTotalForce(); + + public native @Const @ByRef btVector3 getTotalTorque(); + + public native @Const @ByRef btVector3 getInvInertiaDiagLocal(); + + public native void setInvInertiaDiagLocal(@Const @ByRef btVector3 diagInvInertia); + + public native void setSleepingThresholds(@Cast("btScalar") float linear, @Cast("btScalar") float angular); + + public native void applyTorque(@Const @ByRef btVector3 torque); + + public native void applyForce(@Const @ByRef btVector3 force, @Const @ByRef btVector3 rel_pos); + + public native void applyCentralImpulse(@Const @ByRef btVector3 impulse); + + public native void applyTorqueImpulse(@Const @ByRef btVector3 torque); + + public native void applyImpulse(@Const @ByRef btVector3 impulse, @Const @ByRef btVector3 rel_pos); + + public native void applyPushImpulse(@Const @ByRef btVector3 impulse, @Const @ByRef btVector3 rel_pos); + + public native @ByVal btVector3 getPushVelocity(); + + public native @ByVal btVector3 getTurnVelocity(); + + public native void setPushVelocity(@Const @ByRef btVector3 v); + +// #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 +// #endif + + public native void setTurnVelocity(@Const @ByRef btVector3 v); + + public native void applyCentralPushImpulse(@Const @ByRef btVector3 impulse); + + public native void applyTorqueTurnImpulse(@Const @ByRef btVector3 torque); + + public native void clearForces(); + + public native void updateInertiaTensor(); + + public native @Const @ByRef btVector3 getCenterOfMassPosition(); + public native @ByVal btQuaternion getOrientation(); + + public native @Const @ByRef btTransform getCenterOfMassTransform(); + public native @Const @ByRef btVector3 getLinearVelocity(); + public native @Const @ByRef btVector3 getAngularVelocity(); + + public native void setLinearVelocity(@Const @ByRef btVector3 lin_vel); + + public native void setAngularVelocity(@Const @ByRef btVector3 ang_vel); + + public native @ByVal btVector3 getVelocityInLocalPoint(@Const @ByRef btVector3 rel_pos); + + public native @ByVal btVector3 getPushVelocityInLocalPoint(@Const @ByRef btVector3 rel_pos); + + public native void translate(@Const @ByRef btVector3 v); + + public native void getAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native @Cast("btScalar") float computeImpulseDenominator(@Const @ByRef btVector3 pos, @Const @ByRef btVector3 normal); + + public native @Cast("btScalar") float computeAngularImpulseDenominator(@Const @ByRef btVector3 axis); + + public native void updateDeactivation(@Cast("btScalar") float timeStep); + + public native @Cast("bool") boolean wantsSleeping(); + public native btBroadphaseProxy getBroadphaseProxy(); + public native void setNewBroadphaseProxy(btBroadphaseProxy broadphaseProxy); + + //btMotionState allows to automatic synchronize the world transform for active objects + public native btMotionState getMotionState(); + public native void setMotionState(btMotionState motionState); + + //for experimental overriding of friction/contact solver func + public native int m_contactSolverType(); public native btRigidBody m_contactSolverType(int setter); + public native int m_frictionSolverType(); public native btRigidBody m_frictionSolverType(int setter); + + public native void setAngularFactor(@Const @ByRef btVector3 angFac); + + public native void setAngularFactor(@Cast("btScalar") float angFac); + public native @Const @ByRef btVector3 getAngularFactor(); + + //is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBroadphase? + public native @Cast("bool") boolean isInWorld(); + + public native void addConstraintRef(btTypedConstraint c); + public native void removeConstraintRef(btTypedConstraint c); + + public native btTypedConstraint getConstraintRef(int index); + + public native int getNumConstraintRefs(); + + public native void setFlags(int flags); + + public native int getFlags(); + + /**perform implicit force computation in world space */ + public native @ByVal btVector3 computeGyroscopicImpulseImplicit_World(@Cast("btScalar") float dt); + + /**perform implicit force computation in body space (inertial frame) */ + public native @ByVal btVector3 computeGyroscopicImpulseImplicit_Body(@Cast("btScalar") float step); + + /**explicit version is best avoided, it gains energy */ + public native @ByVal btVector3 computeGyroscopicForceExplicit(@Cast("btScalar") float maxGyroscopicForce); + public native @ByVal btVector3 getLocalInertia(); + + /////////////////////////////////////////////// + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void serializeSingleObject(btSerializer serializer); +} + +//@todo add m_optionalMotionState and m_constraintRefs to btRigidBodyData +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btRigidBodyFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btRigidBodyFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btRigidBodyFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBodyFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btRigidBodyFloatData position(long position) { + return (btRigidBodyFloatData)super.position(position); + } + @Override public btRigidBodyFloatData getPointer(long i) { + return new btRigidBodyFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionObjectFloatData m_collisionObjectData(); public native btRigidBodyFloatData m_collisionObjectData(btCollisionObjectFloatData setter); + public native @ByRef btMatrix3x3FloatData m_invInertiaTensorWorld(); public native btRigidBodyFloatData m_invInertiaTensorWorld(btMatrix3x3FloatData setter); + public native @ByRef btVector3FloatData m_linearVelocity(); public native btRigidBodyFloatData m_linearVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularVelocity(); public native btRigidBodyFloatData m_angularVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularFactor(); public native btRigidBodyFloatData m_angularFactor(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearFactor(); public native btRigidBodyFloatData m_linearFactor(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_gravity(); public native btRigidBodyFloatData m_gravity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_gravity_acceleration(); public native btRigidBodyFloatData m_gravity_acceleration(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_invInertiaLocal(); public native btRigidBodyFloatData m_invInertiaLocal(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_totalForce(); public native btRigidBodyFloatData m_totalForce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_totalTorque(); public native btRigidBodyFloatData m_totalTorque(btVector3FloatData setter); + public native float m_inverseMass(); public native btRigidBodyFloatData m_inverseMass(float setter); + public native float m_linearDamping(); public native btRigidBodyFloatData m_linearDamping(float setter); + public native float m_angularDamping(); public native btRigidBodyFloatData m_angularDamping(float setter); + public native float m_additionalDampingFactor(); public native btRigidBodyFloatData m_additionalDampingFactor(float setter); + public native float m_additionalLinearDampingThresholdSqr(); public native btRigidBodyFloatData m_additionalLinearDampingThresholdSqr(float setter); + public native float m_additionalAngularDampingThresholdSqr(); public native btRigidBodyFloatData m_additionalAngularDampingThresholdSqr(float setter); + public native float m_additionalAngularDampingFactor(); public native btRigidBodyFloatData m_additionalAngularDampingFactor(float setter); + public native float m_linearSleepingThreshold(); public native btRigidBodyFloatData m_linearSleepingThreshold(float setter); + public native float m_angularSleepingThreshold(); public native btRigidBodyFloatData m_angularSleepingThreshold(float setter); + public native int m_additionalDamping(); public native btRigidBodyFloatData m_additionalDamping(int setter); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btRigidBodyDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btRigidBodyDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btRigidBodyDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBodyDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btRigidBodyDoubleData position(long position) { + return (btRigidBodyDoubleData)super.position(position); + } + @Override public btRigidBodyDoubleData getPointer(long i) { + return new btRigidBodyDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionObjectDoubleData m_collisionObjectData(); public native btRigidBodyDoubleData m_collisionObjectData(btCollisionObjectDoubleData setter); + public native @ByRef btMatrix3x3DoubleData m_invInertiaTensorWorld(); public native btRigidBodyDoubleData m_invInertiaTensorWorld(btMatrix3x3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearVelocity(); public native btRigidBodyDoubleData m_linearVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularVelocity(); public native btRigidBodyDoubleData m_angularVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularFactor(); public native btRigidBodyDoubleData m_angularFactor(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearFactor(); public native btRigidBodyDoubleData m_linearFactor(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_gravity(); public native btRigidBodyDoubleData m_gravity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_gravity_acceleration(); public native btRigidBodyDoubleData m_gravity_acceleration(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_invInertiaLocal(); public native btRigidBodyDoubleData m_invInertiaLocal(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_totalForce(); public native btRigidBodyDoubleData m_totalForce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_totalTorque(); public native btRigidBodyDoubleData m_totalTorque(btVector3DoubleData setter); + public native double m_inverseMass(); public native btRigidBodyDoubleData m_inverseMass(double setter); + public native double m_linearDamping(); public native btRigidBodyDoubleData m_linearDamping(double setter); + public native double m_angularDamping(); public native btRigidBodyDoubleData m_angularDamping(double setter); + public native double m_additionalDampingFactor(); public native btRigidBodyDoubleData m_additionalDampingFactor(double setter); + public native double m_additionalLinearDampingThresholdSqr(); public native btRigidBodyDoubleData m_additionalLinearDampingThresholdSqr(double setter); + public native double m_additionalAngularDampingThresholdSqr(); public native btRigidBodyDoubleData m_additionalAngularDampingThresholdSqr(double setter); + public native double m_additionalAngularDampingFactor(); public native btRigidBodyDoubleData m_additionalAngularDampingFactor(double setter); + public native double m_linearSleepingThreshold(); public native btRigidBodyDoubleData m_linearSleepingThreshold(double setter); + public native double m_angularSleepingThreshold(); public native btRigidBodyDoubleData m_angularSleepingThreshold(double setter); + public native int m_additionalDamping(); public native btRigidBodyDoubleData m_additionalDamping(int setter); + public native @Cast("char") byte m_padding(int i); public native btRigidBodyDoubleData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + +// #endif //BT_RIGIDBODY_H + + +// Parsed from BulletDynamics/Dynamics/btDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DYNAMICS_WORLD_H +// #define BT_DYNAMICS_WORLD_H + +// #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" +// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +@Opaque public static class btActionInterface extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btActionInterface() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btActionInterface(Pointer p) { super(p); } +} + +/** Type for the callback for each tick */ +public static class btInternalTickCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btInternalTickCallback(Pointer p) { super(p); } + protected btInternalTickCallback() { allocate(); } + private native void allocate(); + public native void call(btDynamicsWorld world, @Cast("btScalar") float timeStep); +} + +/** enum btDynamicsWorldType */ +public static final int + BT_SIMPLE_DYNAMICS_WORLD = 1, + BT_DISCRETE_DYNAMICS_WORLD = 2, + BT_CONTINUOUS_DYNAMICS_WORLD = 3, + BT_SOFT_RIGID_DYNAMICS_WORLD = 4, + BT_GPU_DYNAMICS_WORLD = 5, + BT_SOFT_MULTIBODY_DYNAMICS_WORLD = 6, + BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD = 7; + +/**The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc. */ +@NoOffset public static class btDynamicsWorld extends btCollisionWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDynamicsWorld(Pointer p) { super(p); } + + + /**stepSimulation proceeds the simulation over 'timeStep', units in preferably in seconds. + * By default, Bullet will subdivide the timestep in constant substeps of each 'fixedTimeStep'. + * in order to keep the simulation real-time, the maximum number of substeps can be clamped to 'maxSubSteps'. + * You can disable subdividing the timestep/substepping by passing maxSubSteps=0 as second argument to stepSimulation, but in that case you have to keep the timeStep constant. */ + public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); + public native int stepSimulation(@Cast("btScalar") float timeStep); + + public native void debugDrawWorld(); + + public native void addConstraint(btTypedConstraint constraint, @Cast("bool") boolean disableCollisionsBetweenLinkedBodies/*=false*/); + public native void addConstraint(btTypedConstraint constraint); + + public native void removeConstraint(btTypedConstraint constraint); + + public native void addAction(btActionInterface action); + + public native void removeAction(btActionInterface action); + + //once a rigidbody is added to the dynamics world, it will get this gravity assigned + //existing rigidbodies in the world get gravity assigned too, during this method + public native void setGravity(@Const @ByRef btVector3 gravity); + public native @ByVal btVector3 getGravity(); + + public native void synchronizeMotionStates(); + + public native void addRigidBody(btRigidBody body); + + public native void addRigidBody(btRigidBody body, int group, int mask); + + public native void removeRigidBody(btRigidBody body); + + public native void setConstraintSolver(btConstraintSolver solver); + + public native btConstraintSolver getConstraintSolver(); + + public native int getNumConstraints(); + + public native btTypedConstraint getConstraint(int index); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + public native void clearForces(); + + /** Set the callback for when an internal tick (simulation substep) happens, optional user info */ + public native void setInternalTickCallback(btInternalTickCallback cb, Pointer worldUserInfo/*=0*/, @Cast("bool") boolean isPreTick/*=false*/); + public native void setInternalTickCallback(btInternalTickCallback cb); + + public native void setWorldUserInfo(Pointer worldUserInfo); + + public native Pointer getWorldUserInfo(); + + public native @ByRef btContactSolverInfo getSolverInfo(); + + /**obsolete, use addAction instead. */ + public native void addVehicle(btActionInterface vehicle); + /**obsolete, use removeAction instead */ + public native void removeVehicle(btActionInterface vehicle); + /**obsolete, use addAction instead. */ + public native void addCharacter(btActionInterface character); + /**obsolete, use removeAction instead */ + public native void removeCharacter(btActionInterface character); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btDynamicsWorldDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btDynamicsWorldDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDynamicsWorldDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDynamicsWorldDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btDynamicsWorldDoubleData position(long position) { + return (btDynamicsWorldDoubleData)super.position(position); + } + @Override public btDynamicsWorldDoubleData getPointer(long i) { + return new btDynamicsWorldDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btContactSolverInfoDoubleData m_solverInfo(); public native btDynamicsWorldDoubleData m_solverInfo(btContactSolverInfoDoubleData setter); + public native @ByRef btVector3DoubleData m_gravity(); public native btDynamicsWorldDoubleData m_gravity(btVector3DoubleData setter); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btDynamicsWorldFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btDynamicsWorldFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDynamicsWorldFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDynamicsWorldFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btDynamicsWorldFloatData position(long position) { + return (btDynamicsWorldFloatData)super.position(position); + } + @Override public btDynamicsWorldFloatData getPointer(long i) { + return new btDynamicsWorldFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btContactSolverInfoFloatData m_solverInfo(); public native btDynamicsWorldFloatData m_solverInfo(btContactSolverInfoFloatData setter); + public native @ByRef btVector3FloatData m_gravity(); public native btDynamicsWorldFloatData m_gravity(btVector3FloatData setter); +} + +// #endif //BT_DYNAMICS_WORLD_H + + +// Parsed from BulletDynamics/ConstraintSolver/btContactSolverInfo.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONTACT_SOLVER_INFO +// #define BT_CONTACT_SOLVER_INFO + +// #include "LinearMath/btScalar.h" + +/** enum btSolverMode */ +public static final int + SOLVER_RANDMIZE_ORDER = 1, + SOLVER_FRICTION_SEPARATE = 2, + SOLVER_USE_WARMSTARTING = 4, + SOLVER_USE_2_FRICTION_DIRECTIONS = 16, + SOLVER_ENABLE_FRICTION_DIRECTION_CACHING = 32, + SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION = 64, + SOLVER_CACHE_FRIENDLY = 128, + SOLVER_SIMD = 256, + SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS = 512, + SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS = 1024, + SOLVER_DISABLE_IMPLICIT_CONE_FRICTION = 2048, + SOLVER_USE_ARTICULATED_WARMSTARTING = 4096; + +public static class btContactSolverInfoData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btContactSolverInfoData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactSolverInfoData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactSolverInfoData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btContactSolverInfoData position(long position) { + return (btContactSolverInfoData)super.position(position); + } + @Override public btContactSolverInfoData getPointer(long i) { + return new btContactSolverInfoData((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_tau(); public native btContactSolverInfoData m_tau(float setter); + public native @Cast("btScalar") float m_damping(); public native btContactSolverInfoData m_damping(float setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native @Cast("btScalar") float m_friction(); public native btContactSolverInfoData m_friction(float setter); + public native @Cast("btScalar") float m_timeStep(); public native btContactSolverInfoData m_timeStep(float setter); + public native @Cast("btScalar") float m_restitution(); public native btContactSolverInfoData m_restitution(float setter); + public native int m_numIterations(); public native btContactSolverInfoData m_numIterations(int setter); + public native @Cast("btScalar") float m_maxErrorReduction(); public native btContactSolverInfoData m_maxErrorReduction(float setter); + public native @Cast("btScalar") float m_sor(); public native btContactSolverInfoData m_sor(float setter); //successive over-relaxation term + public native @Cast("btScalar") float m_erp(); public native btContactSolverInfoData m_erp(float setter); //error reduction for non-contact constraints + public native @Cast("btScalar") float m_erp2(); public native btContactSolverInfoData m_erp2(float setter); //error reduction for contact constraints + public native @Cast("btScalar") float m_deformable_erp(); public native btContactSolverInfoData m_deformable_erp(float setter); //error reduction for deformable constraints + public native @Cast("btScalar") float m_deformable_cfm(); public native btContactSolverInfoData m_deformable_cfm(float setter); //constraint force mixing for deformable constraints + public native @Cast("btScalar") float m_deformable_maxErrorReduction(); public native btContactSolverInfoData m_deformable_maxErrorReduction(float setter); // maxErrorReduction for deformable contact + public native @Cast("btScalar") float m_globalCfm(); public native btContactSolverInfoData m_globalCfm(float setter); //constraint force mixing for contacts and non-contacts + public native @Cast("btScalar") float m_frictionERP(); public native btContactSolverInfoData m_frictionERP(float setter); //error reduction for friction constraints + public native @Cast("btScalar") float m_frictionCFM(); public native btContactSolverInfoData m_frictionCFM(float setter); //constraint force mixing for friction constraints + + public native int m_splitImpulse(); public native btContactSolverInfoData m_splitImpulse(int setter); + public native @Cast("btScalar") float m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoData m_splitImpulsePenetrationThreshold(float setter); + public native @Cast("btScalar") float m_splitImpulseTurnErp(); public native btContactSolverInfoData m_splitImpulseTurnErp(float setter); + public native @Cast("btScalar") float m_linearSlop(); public native btContactSolverInfoData m_linearSlop(float setter); + public native @Cast("btScalar") float m_warmstartingFactor(); public native btContactSolverInfoData m_warmstartingFactor(float setter); + public native @Cast("btScalar") float m_articulatedWarmstartingFactor(); public native btContactSolverInfoData m_articulatedWarmstartingFactor(float setter); + public native int m_solverMode(); public native btContactSolverInfoData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoData m_restingContactRestitutionThreshold(int setter); + public native int m_minimumSolverBatchSize(); public native btContactSolverInfoData m_minimumSolverBatchSize(int setter); + public native @Cast("btScalar") float m_maxGyroscopicForce(); public native btContactSolverInfoData m_maxGyroscopicForce(float setter); + public native @Cast("btScalar") float m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoData m_singleAxisRollingFrictionThreshold(float setter); + public native @Cast("btScalar") float m_leastSquaresResidualThreshold(); public native btContactSolverInfoData m_leastSquaresResidualThreshold(float setter); + public native @Cast("btScalar") float m_restitutionVelocityThreshold(); public native btContactSolverInfoData m_restitutionVelocityThreshold(float setter); + public native @Cast("bool") boolean m_jointFeedbackInWorldSpace(); public native btContactSolverInfoData m_jointFeedbackInWorldSpace(boolean setter); + public native @Cast("bool") boolean m_jointFeedbackInJointFrame(); public native btContactSolverInfoData m_jointFeedbackInJointFrame(boolean setter); + public native int m_reportSolverAnalytics(); public native btContactSolverInfoData m_reportSolverAnalytics(int setter); + public native int m_numNonContactInnerIterations(); public native btContactSolverInfoData m_numNonContactInnerIterations(int setter); +} + +public static class btContactSolverInfo extends btContactSolverInfoData { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactSolverInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactSolverInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btContactSolverInfo position(long position) { + return (btContactSolverInfo)super.position(position); + } + @Override public btContactSolverInfo getPointer(long i) { + return new btContactSolverInfo((Pointer)this).offsetAddress(i); + } + + public btContactSolverInfo() { super((Pointer)null); allocate(); } + private native void allocate(); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btContactSolverInfoDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btContactSolverInfoDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactSolverInfoDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactSolverInfoDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btContactSolverInfoDoubleData position(long position) { + return (btContactSolverInfoDoubleData)super.position(position); + } + @Override public btContactSolverInfoDoubleData getPointer(long i) { + return new btContactSolverInfoDoubleData((Pointer)this).offsetAddress(i); + } + + public native double m_tau(); public native btContactSolverInfoDoubleData m_tau(double setter); + public native double m_damping(); public native btContactSolverInfoDoubleData m_damping(double setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native double m_friction(); public native btContactSolverInfoDoubleData m_friction(double setter); + public native double m_timeStep(); public native btContactSolverInfoDoubleData m_timeStep(double setter); + public native double m_restitution(); public native btContactSolverInfoDoubleData m_restitution(double setter); + public native double m_maxErrorReduction(); public native btContactSolverInfoDoubleData m_maxErrorReduction(double setter); + public native double m_sor(); public native btContactSolverInfoDoubleData m_sor(double setter); + public native double m_erp(); public native btContactSolverInfoDoubleData m_erp(double setter); //used as Baumgarte factor + public native double m_erp2(); public native btContactSolverInfoDoubleData m_erp2(double setter); //used in Split Impulse + public native double m_globalCfm(); public native btContactSolverInfoDoubleData m_globalCfm(double setter); //constraint force mixing + public native double m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoDoubleData m_splitImpulsePenetrationThreshold(double setter); + public native double m_splitImpulseTurnErp(); public native btContactSolverInfoDoubleData m_splitImpulseTurnErp(double setter); + public native double m_linearSlop(); public native btContactSolverInfoDoubleData m_linearSlop(double setter); + public native double m_warmstartingFactor(); public native btContactSolverInfoDoubleData m_warmstartingFactor(double setter); + public native double m_articulatedWarmstartingFactor(); public native btContactSolverInfoDoubleData m_articulatedWarmstartingFactor(double setter); + public native double m_maxGyroscopicForce(); public native btContactSolverInfoDoubleData m_maxGyroscopicForce(double setter); /**it is only used for 'explicit' version of gyroscopic force */ + public native double m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoDoubleData m_singleAxisRollingFrictionThreshold(double setter); + + public native int m_numIterations(); public native btContactSolverInfoDoubleData m_numIterations(int setter); + public native int m_solverMode(); public native btContactSolverInfoDoubleData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoDoubleData m_restingContactRestitutionThreshold(int setter); + public native int m_minimumSolverBatchSize(); public native btContactSolverInfoDoubleData m_minimumSolverBatchSize(int setter); + public native int m_splitImpulse(); public native btContactSolverInfoDoubleData m_splitImpulse(int setter); + public native @Cast("char") byte m_padding(int i); public native btContactSolverInfoDoubleData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btContactSolverInfoFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btContactSolverInfoFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactSolverInfoFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactSolverInfoFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btContactSolverInfoFloatData position(long position) { + return (btContactSolverInfoFloatData)super.position(position); + } + @Override public btContactSolverInfoFloatData getPointer(long i) { + return new btContactSolverInfoFloatData((Pointer)this).offsetAddress(i); + } + + public native float m_tau(); public native btContactSolverInfoFloatData m_tau(float setter); + public native float m_damping(); public native btContactSolverInfoFloatData m_damping(float setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native float m_friction(); public native btContactSolverInfoFloatData m_friction(float setter); + public native float m_timeStep(); public native btContactSolverInfoFloatData m_timeStep(float setter); + + public native float m_restitution(); public native btContactSolverInfoFloatData m_restitution(float setter); + public native float m_maxErrorReduction(); public native btContactSolverInfoFloatData m_maxErrorReduction(float setter); + public native float m_sor(); public native btContactSolverInfoFloatData m_sor(float setter); + public native float m_erp(); public native btContactSolverInfoFloatData m_erp(float setter); //used as Baumgarte factor + + public native float m_erp2(); public native btContactSolverInfoFloatData m_erp2(float setter); //used in Split Impulse + public native float m_globalCfm(); public native btContactSolverInfoFloatData m_globalCfm(float setter); //constraint force mixing + public native float m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoFloatData m_splitImpulsePenetrationThreshold(float setter); + public native float m_splitImpulseTurnErp(); public native btContactSolverInfoFloatData m_splitImpulseTurnErp(float setter); + + public native float m_linearSlop(); public native btContactSolverInfoFloatData m_linearSlop(float setter); + public native float m_warmstartingFactor(); public native btContactSolverInfoFloatData m_warmstartingFactor(float setter); + public native float m_articulatedWarmstartingFactor(); public native btContactSolverInfoFloatData m_articulatedWarmstartingFactor(float setter); + public native float m_maxGyroscopicForce(); public native btContactSolverInfoFloatData m_maxGyroscopicForce(float setter); + + public native float m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoFloatData m_singleAxisRollingFrictionThreshold(float setter); + public native int m_numIterations(); public native btContactSolverInfoFloatData m_numIterations(int setter); + public native int m_solverMode(); public native btContactSolverInfoFloatData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoFloatData m_restingContactRestitutionThreshold(int setter); + + public native int m_minimumSolverBatchSize(); public native btContactSolverInfoFloatData m_minimumSolverBatchSize(int setter); + public native int m_splitImpulse(); public native btContactSolverInfoFloatData m_splitImpulse(int setter); + +} + +// #endif //BT_CONTACT_SOLVER_INFO + + +// Parsed from BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DISCRETE_DYNAMICS_WORLD_H +// #define BT_DISCRETE_DYNAMICS_WORLD_H + +// #include "btDynamicsWorld.h" +@Opaque public static class btSimulationIslandManager extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSimulationIslandManager() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimulationIslandManager(Pointer p) { super(p); } +} +@Opaque public static class btPersistentManifold extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btPersistentManifold() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPersistentManifold(Pointer p) { super(p); } +} + +@Opaque public static class InplaceSolverIslandCallback extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public InplaceSolverIslandCallback() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public InplaceSolverIslandCallback(Pointer p) { super(p); } +} + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btThreads.h" + +/**btDiscreteDynamicsWorld provides discrete rigid body simulation + * those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController */ +@NoOffset public static class btDiscreteDynamicsWorld extends btDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDiscreteDynamicsWorld(Pointer p) { super(p); } + + + /**this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those */ + public btDiscreteDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); + + /**if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's */ + public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); + public native int stepSimulation(@Cast("btScalar") float timeStep); + + public native void solveConstraints(@ByRef btContactSolverInfo solverInfo); + + public native void synchronizeMotionStates(); + + /**this can be useful to synchronize a single rigid body -> graphics object */ + public native void synchronizeSingleMotionState(btRigidBody body); + + public native void addConstraint(btTypedConstraint constraint, @Cast("bool") boolean disableCollisionsBetweenLinkedBodies/*=false*/); + public native void addConstraint(btTypedConstraint constraint); + + public native void removeConstraint(btTypedConstraint constraint); + + public native void addAction(btActionInterface arg0); + + public native void removeAction(btActionInterface arg0); + + public native btSimulationIslandManager getSimulationIslandManager(); + + public native btCollisionWorld getCollisionWorld(); + + public native void setGravity(@Const @ByRef btVector3 gravity); + + public native @ByVal btVector3 getGravity(); + + public native void addCollisionObject(btCollisionObject collisionObject, int collisionFilterGroup/*=btBroadphaseProxy::StaticFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter*/); + public native void addCollisionObject(btCollisionObject collisionObject); + + public native void addRigidBody(btRigidBody body); + + public native void addRigidBody(btRigidBody body, int group, int mask); + + public native void removeRigidBody(btRigidBody body); + + /**removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject */ + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native void debugDrawConstraint(btTypedConstraint constraint); + + public native void debugDrawWorld(); + + public native void setConstraintSolver(btConstraintSolver solver); + + public native btConstraintSolver getConstraintSolver(); + + public native int getNumConstraints(); + + public native btTypedConstraint getConstraint(int index); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + /**the forces on each rigidbody is accumulating together with gravity. clear this after each timestep. */ + public native void clearForces(); + + /**apply gravity, call this once per timestep */ + public native void applyGravity(); + + public native void setNumTasks(int numTasks); + + /**obsolete, use updateActions instead */ + public native void updateVehicles(@Cast("btScalar") float timeStep); + + /**obsolete, use addAction instead */ + public native void addVehicle(btActionInterface vehicle); + /**obsolete, use removeAction instead */ + public native void removeVehicle(btActionInterface vehicle); + /**obsolete, use addAction instead */ + public native void addCharacter(btActionInterface character); + /**obsolete, use removeAction instead */ + public native void removeCharacter(btActionInterface character); + + public native void setSynchronizeAllMotionStates(@Cast("bool") boolean synchronizeAll); + public native @Cast("bool") boolean getSynchronizeAllMotionStates(); + + public native void setApplySpeculativeContactRestitution(@Cast("bool") boolean enable); + + public native @Cast("bool") boolean getApplySpeculativeContactRestitution(); + + /**Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see Bullet/Demos/SerializeDemo) */ + public native void serialize(btSerializer serializer); + + /**Interpolate motion state between previous and current transform, instead of current and next transform. + * This can relieve discontinuities in the rendering, due to penetrations */ + public native void setLatencyMotionStateInterpolation(@Cast("bool") boolean latencyInterpolation); + public native @Cast("bool") boolean getLatencyMotionStateInterpolation(); + + public native @ByRef btAlignedObjectArray_btRigidBodyPointer getNonStaticRigidBodies(); +} + +// #endif //BT_DISCRETE_DYNAMICS_WORLD_H + + +// Parsed from BulletDynamics/Dynamics/btSimpleDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMPLE_DYNAMICS_WORLD_H +// #define BT_SIMPLE_DYNAMICS_WORLD_H + +// #include "btDynamicsWorld.h" + +/**The btSimpleDynamicsWorld serves as unit-test and to verify more complicated and optimized dynamics worlds. + * Please use btDiscreteDynamicsWorld instead */ +@NoOffset public static class btSimpleDynamicsWorld extends btDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimpleDynamicsWorld(Pointer p) { super(p); } + + /**this btSimpleDynamicsWorld constructor creates dispatcher, broadphase pairCache and constraintSolver */ + public btSimpleDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); + + /**maxSubSteps/fixedTimeStep for interpolation is currently ignored for btSimpleDynamicsWorld, use btDiscreteDynamicsWorld instead */ + public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); + public native int stepSimulation(@Cast("btScalar") float timeStep); + + public native void setGravity(@Const @ByRef btVector3 gravity); + + public native @ByVal btVector3 getGravity(); + + public native void addRigidBody(btRigidBody body); + + public native void addRigidBody(btRigidBody body, int group, int mask); + + public native void removeRigidBody(btRigidBody body); + + public native void debugDrawWorld(); + + public native void addAction(btActionInterface action); + + public native void removeAction(btActionInterface action); + + /**removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject */ + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native void updateAabbs(); + + public native void synchronizeMotionStates(); + + public native void setConstraintSolver(btConstraintSolver solver); + + public native btConstraintSolver getConstraintSolver(); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + public native void clearForces(); +} + +// #endif //BT_SIMPLE_DYNAMICS_WORLD_H + + +// Parsed from BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_POINT2POINTCONSTRAINT_H +// #define BT_POINT2POINTCONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btPoint2PointConstraintData2 btPoint2PointConstraintFloatData +public static final String btPoint2PointConstraintDataName = "btPoint2PointConstraintFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +@NoOffset public static class btConstraintSetting extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintSetting(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConstraintSetting(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btConstraintSetting position(long position) { + return (btConstraintSetting)super.position(position); + } + @Override public btConstraintSetting getPointer(long i) { + return new btConstraintSetting((Pointer)this).offsetAddress(i); + } + + public btConstraintSetting() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float m_tau(); public native btConstraintSetting m_tau(float setter); + public native @Cast("btScalar") float m_damping(); public native btConstraintSetting m_damping(float setter); + public native @Cast("btScalar") float m_impulseClamp(); public native btConstraintSetting m_impulseClamp(float setter); +} + +/** enum btPoint2PointFlags */ +public static final int + BT_P2P_FLAGS_ERP = 1, + BT_P2P_FLAGS_CFM = 2; + +/** point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space */ +@NoOffset public static class btPoint2PointConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraint(Pointer p) { super(p); } + + + /**for backwards compatibility during the transition to 'getInfo/getInfo2' */ + public native @Cast("bool") boolean m_useSolveConstraintObsolete(); public native btPoint2PointConstraint m_useSolveConstraintObsolete(boolean setter); + + public native @ByRef btConstraintSetting m_setting(); public native btPoint2PointConstraint m_setting(btConstraintSetting setter); + + public btPoint2PointConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB); + + public btPoint2PointConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA) { super((Pointer)null); allocate(rbA, pivotInA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA); + + public native void buildJacobian(); + + public native void updateRHS(@Cast("btScalar") float timeStep); + + public native void setPivotA(@Const @ByRef btVector3 pivotA); + + public native void setPivotB(@Const @ByRef btVector3 pivotB); + + public native @Const @ByRef btVector3 getPivotInA(); + + public native @Const @ByRef btVector3 getPivotInB(); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btPoint2PointConstraintFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPoint2PointConstraintFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPoint2PointConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraintFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPoint2PointConstraintFloatData position(long position) { + return (btPoint2PointConstraintFloatData)super.position(position); + } + @Override public btPoint2PointConstraintFloatData getPointer(long i) { + return new btPoint2PointConstraintFloatData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btVector3FloatData m_pivotInA(); public native btPoint2PointConstraintFloatData m_pivotInA(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_pivotInB(); public native btPoint2PointConstraintFloatData m_pivotInB(btVector3FloatData setter); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btPoint2PointConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPoint2PointConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPoint2PointConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPoint2PointConstraintDoubleData2 position(long position) { + return (btPoint2PointConstraintDoubleData2)super.position(position); + } + @Override public btPoint2PointConstraintDoubleData2 getPointer(long i) { + return new btPoint2PointConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btVector3DoubleData m_pivotInA(); public native btPoint2PointConstraintDoubleData2 m_pivotInA(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_pivotInB(); public native btPoint2PointConstraintDoubleData2 m_pivotInB(btVector3DoubleData setter); +} + +// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 + * this structure is not used, except for loading pre-2.82 .bullet files + * do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btPoint2PointConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPoint2PointConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPoint2PointConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPoint2PointConstraintDoubleData position(long position) { + return (btPoint2PointConstraintDoubleData)super.position(position); + } + @Override public btPoint2PointConstraintDoubleData getPointer(long i) { + return new btPoint2PointConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btVector3DoubleData m_pivotInA(); public native btPoint2PointConstraintDoubleData m_pivotInA(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_pivotInB(); public native btPoint2PointConstraintDoubleData m_pivotInB(btVector3DoubleData setter); +} +// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_POINT2POINTCONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btHingeConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* Hinge Constraint by Dirk Gregorius. Limits added by Marcus Hennix at Starbreeze Studios */ + +// #ifndef BT_HINGECONSTRAINT_H +// #define BT_HINGECONSTRAINT_H + +public static final int _BT_USE_CENTER_LIMIT_ = 1; + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btHingeConstraintData btHingeConstraintFloatData +public static final String btHingeConstraintDataName = "btHingeConstraintFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum btHingeFlags */ +public static final int + BT_HINGE_FLAGS_CFM_STOP = 1, + BT_HINGE_FLAGS_ERP_STOP = 2, + BT_HINGE_FLAGS_CFM_NORM = 4, + BT_HINGE_FLAGS_ERP_NORM = 8; + +/** hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space + * axis defines the orientation of the hinge axis */ +@NoOffset public static class btHingeConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraint(Pointer p) { super(p); } + + + public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); + + public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, pivotInA, axisInA, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA) { super((Pointer)null); allocate(rbA, pivotInA, axisInA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA); + + public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); + + public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbAFrame, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); + + public native void buildJacobian(); + + public native void updateRHS(@Cast("btScalar") float timeStep); + + public native @ByRef btRigidBody getRigidBodyA(); + + public native @ByRef btRigidBody getRigidBodyB(); + + public native @ByRef btTransform getFrameOffsetA(); + + public native @ByRef btTransform getFrameOffsetB(); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + public native void setAngularOnly(@Cast("bool") boolean angularOnly); + + public native void enableAngularMotor(@Cast("bool") boolean enableMotor, @Cast("btScalar") float targetVelocity, @Cast("btScalar") float maxMotorImpulse); + + // extra motor API, including ability to set a target rotation (as opposed to angular velocity) + // note: setMotorTarget sets angular velocity under the hood, so you must call it every tick to + // maintain a given angular target. + public native void enableMotor(@Cast("bool") boolean enableMotor); + public native void setMaxMotorImpulse(@Cast("btScalar") float maxMotorImpulse); + public native void setMotorTargetVelocity(@Cast("btScalar") float motorTargetVelocity); + public native void setMotorTarget(@Const @ByRef btQuaternion qAinB, @Cast("btScalar") float dt); // qAinB is rotation of body A wrt body B. + public native void setMotorTarget(@Cast("btScalar") float targetAngle, @Cast("btScalar") float dt); + + public native void setLimit(@Cast("btScalar") float low, @Cast("btScalar") float high, @Cast("btScalar") float _softness/*=0.9f*/, @Cast("btScalar") float _biasFactor/*=0.3f*/, @Cast("btScalar") float _relaxationFactor/*=1.0f*/); + public native void setLimit(@Cast("btScalar") float low, @Cast("btScalar") float high); + + public native @Cast("btScalar") float getLimitSoftness(); + + public native @Cast("btScalar") float getLimitBiasFactor(); + + public native @Cast("btScalar") float getLimitRelaxationFactor(); + + public native void setAxis(@ByRef btVector3 axisInA); + + public native @Cast("bool") boolean hasLimit(); + + public native @Cast("btScalar") float getLowerLimit(); + + public native @Cast("btScalar") float getUpperLimit(); + + /**The getHingeAngle gives the hinge angle in range [-PI,PI] */ + public native @Cast("btScalar") float getHingeAngle(); + + public native @Cast("btScalar") float getHingeAngle(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + + public native void testLimit(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + + public native @ByRef btTransform getAFrame(); + public native @ByRef btTransform getBFrame(); + + public native int getSolveLimit(); + + public native @Cast("btScalar") float getLimitSign(); + + public native @Cast("bool") boolean getAngularOnly(); + public native @Cast("bool") boolean getEnableAngularMotor(); + public native @Cast("btScalar") float getMotorTargetVelocity(); + public native @Cast("btScalar") float getMaxMotorImpulse(); + // access for UseFrameOffset + public native @Cast("bool") boolean getUseFrameOffset(); + public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); + // access for UseReferenceFrameA + public native @Cast("bool") boolean getUseReferenceFrameA(); + public native void setUseReferenceFrameA(@Cast("bool") boolean useReferenceFrameA); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +//only for backward compatibility +// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +/**this structure is not used, except for loading pre-2.82 .bullet files */ +public static class btHingeConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHingeConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHingeConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHingeConstraintDoubleData position(long position) { + return (btHingeConstraintDoubleData)super.position(position); + } + @Override public btHingeConstraintDoubleData getPointer(long i) { + return new btHingeConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btHingeConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btHingeConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); + public native int m_useReferenceFrameA(); public native btHingeConstraintDoubleData m_useReferenceFrameA(int setter); + public native int m_angularOnly(); public native btHingeConstraintDoubleData m_angularOnly(int setter); + public native int m_enableAngularMotor(); public native btHingeConstraintDoubleData m_enableAngularMotor(int setter); + public native float m_motorTargetVelocity(); public native btHingeConstraintDoubleData m_motorTargetVelocity(float setter); + public native float m_maxMotorImpulse(); public native btHingeConstraintDoubleData m_maxMotorImpulse(float setter); + + public native float m_lowerLimit(); public native btHingeConstraintDoubleData m_lowerLimit(float setter); + public native float m_upperLimit(); public native btHingeConstraintDoubleData m_upperLimit(float setter); + public native float m_limitSoftness(); public native btHingeConstraintDoubleData m_limitSoftness(float setter); + public native float m_biasFactor(); public native btHingeConstraintDoubleData m_biasFactor(float setter); + public native float m_relaxationFactor(); public native btHingeConstraintDoubleData m_relaxationFactor(float setter); +} +// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION + +/**The getAccumulatedHingeAngle returns the accumulated hinge angle, taking rotation across the -PI/PI boundary into account */ +@NoOffset public static class btHingeAccumulatedAngleConstraint extends btHingeConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeAccumulatedAngleConstraint(Pointer p) { super(p); } + + + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); + + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, pivotInA, axisInA, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA) { super((Pointer)null); allocate(rbA, pivotInA, axisInA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA); + + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); + + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbAFrame, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); + public native @Cast("btScalar") float getAccumulatedHingeAngle(); + public native void setAccumulatedHingeAngle(@Cast("btScalar") float accAngle); +} + +public static class btHingeConstraintFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHingeConstraintFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHingeConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraintFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHingeConstraintFloatData position(long position) { + return (btHingeConstraintFloatData)super.position(position); + } + @Override public btHingeConstraintFloatData getPointer(long i) { + return new btHingeConstraintFloatData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btHingeConstraintFloatData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformFloatData m_rbBFrame(); public native btHingeConstraintFloatData m_rbBFrame(btTransformFloatData setter); + public native int m_useReferenceFrameA(); public native btHingeConstraintFloatData m_useReferenceFrameA(int setter); + public native int m_angularOnly(); public native btHingeConstraintFloatData m_angularOnly(int setter); + + public native int m_enableAngularMotor(); public native btHingeConstraintFloatData m_enableAngularMotor(int setter); + public native float m_motorTargetVelocity(); public native btHingeConstraintFloatData m_motorTargetVelocity(float setter); + public native float m_maxMotorImpulse(); public native btHingeConstraintFloatData m_maxMotorImpulse(float setter); + + public native float m_lowerLimit(); public native btHingeConstraintFloatData m_lowerLimit(float setter); + public native float m_upperLimit(); public native btHingeConstraintFloatData m_upperLimit(float setter); + public native float m_limitSoftness(); public native btHingeConstraintFloatData m_limitSoftness(float setter); + public native float m_biasFactor(); public native btHingeConstraintFloatData m_biasFactor(float setter); + public native float m_relaxationFactor(); public native btHingeConstraintFloatData m_relaxationFactor(float setter); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btHingeConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHingeConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHingeConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHingeConstraintDoubleData2 position(long position) { + return (btHingeConstraintDoubleData2)super.position(position); + } + @Override public btHingeConstraintDoubleData2 getPointer(long i) { + return new btHingeConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btHingeConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btHingeConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); + public native int m_useReferenceFrameA(); public native btHingeConstraintDoubleData2 m_useReferenceFrameA(int setter); + public native int m_angularOnly(); public native btHingeConstraintDoubleData2 m_angularOnly(int setter); + public native int m_enableAngularMotor(); public native btHingeConstraintDoubleData2 m_enableAngularMotor(int setter); + public native double m_motorTargetVelocity(); public native btHingeConstraintDoubleData2 m_motorTargetVelocity(double setter); + public native double m_maxMotorImpulse(); public native btHingeConstraintDoubleData2 m_maxMotorImpulse(double setter); + + public native double m_lowerLimit(); public native btHingeConstraintDoubleData2 m_lowerLimit(double setter); + public native double m_upperLimit(); public native btHingeConstraintDoubleData2 m_upperLimit(double setter); + public native double m_limitSoftness(); public native btHingeConstraintDoubleData2 m_limitSoftness(double setter); + public native double m_biasFactor(); public native btHingeConstraintDoubleData2 m_biasFactor(double setter); + public native double m_relaxationFactor(); public native btHingeConstraintDoubleData2 m_relaxationFactor(double setter); + public native @Cast("char") byte m_padding1(int i); public native btHingeConstraintDoubleData2 m_padding1(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding1(); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_HINGECONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btConeTwistConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. + +Written by: Marcus Hennix +*/ + +/* +Overview: + +btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc). +It is a fixed translation, 3 degree-of-freedom (DOF) rotational "joint". +It divides the 3 rotational DOFs into swing (movement within a cone) and twist. +Swing is divided into swing1 and swing2 which can have different limits, giving an elliptical shape. +(Note: the cone's base isn't flat, so this ellipse is "embedded" on the surface of a sphere.) + +In the contraint's frame of reference: +twist is along the x-axis, +and swing 1 and 2 are along the z and y axes respectively. +*/ + +// #ifndef BT_CONETWISTCONSTRAINT_H +// #define BT_CONETWISTCONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btConeTwistConstraintData2 btConeTwistConstraintData +public static final String btConeTwistConstraintDataName = "btConeTwistConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum btConeTwistFlags */ +public static final int + BT_CONETWIST_FLAGS_LIN_CFM = 1, + BT_CONETWIST_FLAGS_LIN_ERP = 2, + BT_CONETWIST_FLAGS_ANG_CFM = 4; + +/**btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc) */ +@NoOffset public static class btConeTwistConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeTwistConstraint(Pointer p) { super(p); } + + + public btConeTwistConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); + + public btConeTwistConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); + + public native void buildJacobian(); + + + + public native void updateRHS(@Cast("btScalar") float timeStep); + + public native @Const @ByRef btRigidBody getRigidBodyA(); + public native @Const @ByRef btRigidBody getRigidBodyB(); + + public native void setAngularOnly(@Cast("bool") boolean angularOnly); + + public native @Cast("bool") boolean getAngularOnly(); + + public native void setLimit(int limitIndex, @Cast("btScalar") float limitValue); + + public native @Cast("btScalar") float getLimit(int limitIndex); + + // setLimit(), a few notes: + // _softness: + // 0->1, recommend ~0.8->1. + // describes % of limits where movement is free. + // beyond this softness %, the limit is gradually enforced until the "hard" (1.0) limit is reached. + // _biasFactor: + // 0->1?, recommend 0.3 +/-0.3 or so. + // strength with which constraint resists zeroth order (angular, not angular velocity) limit violation. + // __relaxationFactor: + // 0->1, recommend to stay near 1. + // the lower the value, the less the constraint will fight velocities which violate the angular limits. + public native void setLimit(@Cast("btScalar") float _swingSpan1, @Cast("btScalar") float _swingSpan2, @Cast("btScalar") float _twistSpan, @Cast("btScalar") float _softness/*=1.f*/, @Cast("btScalar") float _biasFactor/*=0.3f*/, @Cast("btScalar") float _relaxationFactor/*=1.0f*/); + public native void setLimit(@Cast("btScalar") float _swingSpan1, @Cast("btScalar") float _swingSpan2, @Cast("btScalar") float _twistSpan); + + public native @Const @ByRef btTransform getAFrame(); + public native @Const @ByRef btTransform getBFrame(); + + public native int getSolveTwistLimit(); + + public native int getSolveSwingLimit(); + + public native @Cast("btScalar") float getTwistLimitSign(); + + public native void calcAngleInfo(); + public native void calcAngleInfo2(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btMatrix3x3 invInertiaWorldA, @Const @ByRef btMatrix3x3 invInertiaWorldB); + + public native @Cast("btScalar") float getSwingSpan1(); + public native @Cast("btScalar") float getSwingSpan2(); + public native @Cast("btScalar") float getTwistSpan(); + public native @Cast("btScalar") float getLimitSoftness(); + public native @Cast("btScalar") float getBiasFactor(); + public native @Cast("btScalar") float getRelaxationFactor(); + public native @Cast("btScalar") float getTwistAngle(); + public native @Cast("bool") boolean isPastSwingLimit(); + + public native @Cast("btScalar") float getDamping(); + public native void setDamping(@Cast("btScalar") float damping); + + public native void enableMotor(@Cast("bool") boolean b); + public native @Cast("bool") boolean isMotorEnabled(); + public native @Cast("btScalar") float getMaxMotorImpulse(); + public native @Cast("bool") boolean isMaxMotorImpulseNormalized(); + public native void setMaxMotorImpulse(@Cast("btScalar") float maxMotorImpulse); + public native void setMaxMotorImpulseNormalized(@Cast("btScalar") float maxMotorImpulse); + + public native @Cast("btScalar") float getFixThresh(); + public native void setFixThresh(@Cast("btScalar") float fixThresh); + + // setMotorTarget: + // q: the desired rotation of bodyA wrt bodyB. + // note: if q violates the joint limits, the internal target is clamped to avoid conflicting impulses (very bad for stability) + // note: don't forget to enableMotor() + public native void setMotorTarget(@Const @ByRef btQuaternion q); + public native @Const @ByRef btQuaternion getMotorTarget(); + + // same as above, but q is the desired rotation of frameA wrt frameB in constraint space + public native void setMotorTargetInConstraintSpace(@Const @ByRef btQuaternion q); + + public native @ByVal btVector3 GetPointForAngle(@Cast("btScalar") float fAngleInRadians, @Cast("btScalar") float fLength); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + public native @Const @ByRef btTransform getFrameOffsetA(); + + public native @Const @ByRef btTransform getFrameOffsetB(); + + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +public static class btConeTwistConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConeTwistConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConeTwistConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeTwistConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConeTwistConstraintDoubleData position(long position) { + return (btConeTwistConstraintDoubleData)super.position(position); + } + @Override public btConeTwistConstraintDoubleData getPointer(long i) { + return new btConeTwistConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btConeTwistConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btConeTwistConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); + + //limits + public native double m_swingSpan1(); public native btConeTwistConstraintDoubleData m_swingSpan1(double setter); + public native double m_swingSpan2(); public native btConeTwistConstraintDoubleData m_swingSpan2(double setter); + public native double m_twistSpan(); public native btConeTwistConstraintDoubleData m_twistSpan(double setter); + public native double m_limitSoftness(); public native btConeTwistConstraintDoubleData m_limitSoftness(double setter); + public native double m_biasFactor(); public native btConeTwistConstraintDoubleData m_biasFactor(double setter); + public native double m_relaxationFactor(); public native btConeTwistConstraintDoubleData m_relaxationFactor(double setter); + + public native double m_damping(); public native btConeTwistConstraintDoubleData m_damping(double setter); +} + +// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +/**this structure is not used, except for loading pre-2.82 .bullet files */ +public static class btConeTwistConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConeTwistConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConeTwistConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeTwistConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConeTwistConstraintData position(long position) { + return (btConeTwistConstraintData)super.position(position); + } + @Override public btConeTwistConstraintData getPointer(long i) { + return new btConeTwistConstraintData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btConeTwistConstraintData m_rbAFrame(btTransformFloatData setter); + public native @ByRef btTransformFloatData m_rbBFrame(); public native btConeTwistConstraintData m_rbBFrame(btTransformFloatData setter); + + //limits + public native float m_swingSpan1(); public native btConeTwistConstraintData m_swingSpan1(float setter); + public native float m_swingSpan2(); public native btConeTwistConstraintData m_swingSpan2(float setter); + public native float m_twistSpan(); public native btConeTwistConstraintData m_twistSpan(float setter); + public native float m_limitSoftness(); public native btConeTwistConstraintData m_limitSoftness(float setter); + public native float m_biasFactor(); public native btConeTwistConstraintData m_biasFactor(float setter); + public native float m_relaxationFactor(); public native btConeTwistConstraintData m_relaxationFactor(float setter); + + public native float m_damping(); public native btConeTwistConstraintData m_damping(float setter); + + public native @Cast("char") byte m_pad(int i); public native btConeTwistConstraintData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} +// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION +// + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_CONETWISTCONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ + +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +// #ifndef BT_GENERIC_6DOF_CONSTRAINT_H +// #define BT_GENERIC_6DOF_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGeneric6DofConstraintData2 btGeneric6DofConstraintData +public static final String btGeneric6DofConstraintDataName = "btGeneric6DofConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** Rotation Limit structure for generic joints */ +@NoOffset public static class btRotationalLimitMotor extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRotationalLimitMotor(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btRotationalLimitMotor(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btRotationalLimitMotor position(long position) { + return (btRotationalLimitMotor)super.position(position); + } + @Override public btRotationalLimitMotor getPointer(long i) { + return new btRotationalLimitMotor((Pointer)this).offsetAddress(i); + } + + /** limit_parameters + * \{ */ + /** joint limit */ + public native @Cast("btScalar") float m_loLimit(); public native btRotationalLimitMotor m_loLimit(float setter); + /** joint limit */ + public native @Cast("btScalar") float m_hiLimit(); public native btRotationalLimitMotor m_hiLimit(float setter); + /** target motor velocity */ + public native @Cast("btScalar") float m_targetVelocity(); public native btRotationalLimitMotor m_targetVelocity(float setter); + /** max force on motor */ + public native @Cast("btScalar") float m_maxMotorForce(); public native btRotationalLimitMotor m_maxMotorForce(float setter); + /** max force on limit */ + public native @Cast("btScalar") float m_maxLimitForce(); public native btRotationalLimitMotor m_maxLimitForce(float setter); + /** Damping. */ + public native @Cast("btScalar") float m_damping(); public native btRotationalLimitMotor m_damping(float setter); + public native @Cast("btScalar") float m_limitSoftness(); public native btRotationalLimitMotor m_limitSoftness(float setter); /** Relaxation factor */ + /** Constraint force mixing factor */ + public native @Cast("btScalar") float m_normalCFM(); public native btRotationalLimitMotor m_normalCFM(float setter); + /** Error tolerance factor when joint is at limit */ + public native @Cast("btScalar") float m_stopERP(); public native btRotationalLimitMotor m_stopERP(float setter); + /** Constraint force mixing factor when joint is at limit */ + public native @Cast("btScalar") float m_stopCFM(); public native btRotationalLimitMotor m_stopCFM(float setter); + /** restitution factor */ + public native @Cast("btScalar") float m_bounce(); public native btRotationalLimitMotor m_bounce(float setter); + public native @Cast("bool") boolean m_enableMotor(); public native btRotationalLimitMotor m_enableMotor(boolean setter); + + /**\} +

+ * temp_variables + * \{ */ + public native @Cast("btScalar") float m_currentLimitError(); public native btRotationalLimitMotor m_currentLimitError(float setter); /** How much is violated this limit */ + public native @Cast("btScalar") float m_currentPosition(); public native btRotationalLimitMotor m_currentPosition(float setter); /** current value of angle */ + /** 0=free, 1=at lo limit, 2=at hi limit */ + public native int m_currentLimit(); public native btRotationalLimitMotor m_currentLimit(int setter); + public native @Cast("btScalar") float m_accumulatedImpulse(); public native btRotationalLimitMotor m_accumulatedImpulse(float setter); + /**\} */ + + public btRotationalLimitMotor() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btRotationalLimitMotor(@Const @ByRef btRotationalLimitMotor limot) { super((Pointer)null); allocate(limot); } + private native void allocate(@Const @ByRef btRotationalLimitMotor limot); + + /** Is limited */ + public native @Cast("bool") boolean isLimited(); + + /** Need apply correction */ + public native @Cast("bool") boolean needApplyTorques(); + + /** calculates error + /** + calculates m_currentLimit and m_currentLimitError. + */ + public native int testLimitValue(@Cast("btScalar") float test_value); + + /** apply the correction impulses for two bodies */ + public native @Cast("btScalar") float solveAngularLimits(@Cast("btScalar") float timeStep, @ByRef btVector3 axis, @Cast("btScalar") float jacDiagABInv, btRigidBody body0, btRigidBody body1); +} + +@NoOffset public static class btTranslationalLimitMotor extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTranslationalLimitMotor(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTranslationalLimitMotor(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTranslationalLimitMotor position(long position) { + return (btTranslationalLimitMotor)super.position(position); + } + @Override public btTranslationalLimitMotor getPointer(long i) { + return new btTranslationalLimitMotor((Pointer)this).offsetAddress(i); + } + + /** the constraint lower limits */ + public native @ByRef btVector3 m_lowerLimit(); public native btTranslationalLimitMotor m_lowerLimit(btVector3 setter); + /** the constraint upper limits */ + public native @ByRef btVector3 m_upperLimit(); public native btTranslationalLimitMotor m_upperLimit(btVector3 setter); + public native @ByRef btVector3 m_accumulatedImpulse(); public native btTranslationalLimitMotor m_accumulatedImpulse(btVector3 setter); + /** Linear_Limit_parameters + * \{ */ + /** Softness for linear limit */ + public native @Cast("btScalar") float m_limitSoftness(); public native btTranslationalLimitMotor m_limitSoftness(float setter); + /** Damping for linear limit */ + public native @Cast("btScalar") float m_damping(); public native btTranslationalLimitMotor m_damping(float setter); + public native @Cast("btScalar") float m_restitution(); public native btTranslationalLimitMotor m_restitution(float setter); /** Bounce parameter for linear limit */ + /** Constraint force mixing factor */ + public native @ByRef btVector3 m_normalCFM(); public native btTranslationalLimitMotor m_normalCFM(btVector3 setter); + /** Error tolerance factor when joint is at limit */ + public native @ByRef btVector3 m_stopERP(); public native btTranslationalLimitMotor m_stopERP(btVector3 setter); + /** Constraint force mixing factor when joint is at limit */ + public native @ByRef btVector3 m_stopCFM(); public native btTranslationalLimitMotor m_stopCFM(btVector3 setter); + /**\} */ + public native @Cast("bool") boolean m_enableMotor(int i); public native btTranslationalLimitMotor m_enableMotor(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_enableMotor(); + /** target motor velocity */ + public native @ByRef btVector3 m_targetVelocity(); public native btTranslationalLimitMotor m_targetVelocity(btVector3 setter); + /** max force on motor */ + public native @ByRef btVector3 m_maxMotorForce(); public native btTranslationalLimitMotor m_maxMotorForce(btVector3 setter); + public native @ByRef btVector3 m_currentLimitError(); public native btTranslationalLimitMotor m_currentLimitError(btVector3 setter); /** How much is violated this limit */ + public native @ByRef btVector3 m_currentLinearDiff(); public native btTranslationalLimitMotor m_currentLinearDiff(btVector3 setter); /** Current relative offset of constraint frames */ + /** 0=free, 1=at lower limit, 2=at upper limit */ + public native int m_currentLimit(int i); public native btTranslationalLimitMotor m_currentLimit(int i, int setter); + @MemberGetter public native IntPointer m_currentLimit(); + + public btTranslationalLimitMotor() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btTranslationalLimitMotor(@Const @ByRef btTranslationalLimitMotor other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btTranslationalLimitMotor other); + + /** Test limit + /** + - free means upper < lower, + - locked means upper == lower + - limited means upper > lower + - limitIndex: first 3 are linear, next 3 are angular + */ + public native @Cast("bool") boolean isLimited(int limitIndex); + public native @Cast("bool") boolean needApplyForce(int limitIndex); + public native int testLimitValue(int limitIndex, @Cast("btScalar") float test_value); + + public native @Cast("btScalar") float solveLinearAxis( + @Cast("btScalar") float timeStep, + @Cast("btScalar") float jacDiagABInv, + @ByRef btRigidBody body1, @Const @ByRef btVector3 pointInA, + @ByRef btRigidBody body2, @Const @ByRef btVector3 pointInB, + int limit_index, + @Const @ByRef btVector3 axis_normal_on_a, + @Const @ByRef btVector3 anchorPos); +} + +/** enum bt6DofFlags */ +public static final int + BT_6DOF_FLAGS_CFM_NORM = 1, + BT_6DOF_FLAGS_CFM_STOP = 2, + BT_6DOF_FLAGS_ERP_STOP = 4; +public static final int BT_6DOF_FLAGS_AXIS_SHIFT = 3; // bits per axis + +/** btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space +/** +btGeneric6DofConstraint can leave any of the 6 degree of freedom 'free' or 'locked'. +currently this limit supports rotational motors
+

    +
  • For Linear limits, use btGeneric6DofConstraint.setLinearUpperLimit, btGeneric6DofConstraint.setLinearLowerLimit. You can set the parameters with the btTranslationalLimitMotor structure accsesible through the btGeneric6DofConstraint.getTranslationalLimitMotor method. +At this moment translational motors are not supported. May be in the future.
    • +

    +

  • For Angular limits, use the btRotationalLimitMotor structure for configuring the limit. +This is accessible through btGeneric6DofConstraint.getLimitMotor method, +This brings support for limit parameters and motors.
    • +

    +

  • Angulars limits have these possible ranges: + + + + + + + + + + + + + + + + + + +
    AXISMIN ANGLEMAX ANGLE
    X-PIPI
    Y-PI/2PI/2
    Z-PIPI
    +
    • +
+

+*/ +@NoOffset public static class btGeneric6DofConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofConstraint(Pointer p) { super(p); } + + + /**for backwards compatibility during the transition to 'getInfo/getInfo2' */ + public native @Cast("bool") boolean m_useSolveConstraintObsolete(); public native btGeneric6DofConstraint m_useSolveConstraintObsolete(boolean setter); + + public btGeneric6DofConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); + public btGeneric6DofConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameB); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB); + + /** Calcs global transform of the offsets + /** + Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies. + @see btGeneric6DofConstraint.getCalculatedTransformA , btGeneric6DofConstraint.getCalculatedTransformB, btGeneric6DofConstraint.calculateAngleInfo + */ + public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + + public native void calculateTransforms(); + + /** Gets the global transform of the offset for body A + /** + @see btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo. + */ + public native @Const @ByRef btTransform getCalculatedTransformA(); + + /** Gets the global transform of the offset for body B + /** + @see btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo. + */ + public native @Const @ByRef btTransform getCalculatedTransformB(); + + public native @ByRef btTransform getFrameOffsetA(); + + public native @ByRef btTransform getFrameOffsetB(); + + /** performs Jacobian calculation, and also calculates angle differences and axis */ + public native void buildJacobian(); + + public native void updateRHS(@Cast("btScalar") float timeStep); + + /** Get the rotation axis in global coordinates + /** + \pre btGeneric6DofConstraint.buildJacobian must be called previously. + */ + public native @ByVal btVector3 getAxis(int axis_index); + + /** Get the relative Euler angle + /** + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("btScalar") float getAngle(int axis_index); + + /** Get the relative position of the constraint pivot + /** + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("btScalar") float getRelativePivotPosition(int axis_index); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + /** Test angular limit. + /** + Calculates angular correction and returns true if limit needs to be corrected. + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("bool") boolean testAngularLimitMotor(int axis_index); + + public native void setLinearLowerLimit(@Const @ByRef btVector3 linearLower); + + public native void getLinearLowerLimit(@ByRef btVector3 linearLower); + + public native void setLinearUpperLimit(@Const @ByRef btVector3 linearUpper); + + public native void getLinearUpperLimit(@ByRef btVector3 linearUpper); + + public native void setAngularLowerLimit(@Const @ByRef btVector3 angularLower); + + public native void getAngularLowerLimit(@ByRef btVector3 angularLower); + + public native void setAngularUpperLimit(@Const @ByRef btVector3 angularUpper); + + public native void getAngularUpperLimit(@ByRef btVector3 angularUpper); + + /** Retrieves the angular limit informacion */ + public native btRotationalLimitMotor getRotationalLimitMotor(int index); + + /** Retrieves the limit informacion */ + public native btTranslationalLimitMotor getTranslationalLimitMotor(); + + //first 3 are linear, next 3 are angular + public native void setLimit(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); + + /** Test limit + /** + - free means upper < lower, + - locked means upper == lower + - limited means upper > lower + - limitIndex: first 3 are linear, next 3 are angular + */ + public native @Cast("bool") boolean isLimited(int limitIndex); + + public native void calcAnchorPos(); // overridable + + // access for UseFrameOffset + public native @Cast("bool") boolean getUseFrameOffset(); + public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); + + public native @Cast("bool") boolean getUseLinearReferenceFrameA(); + public native void setUseLinearReferenceFrameA(@Cast("bool") boolean linearReferenceFrameA); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +public static class btGeneric6DofConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofConstraintData position(long position) { + return (btGeneric6DofConstraintData)super.position(position); + } + @Override public btGeneric6DofConstraintData getPointer(long i) { + return new btGeneric6DofConstraintData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btGeneric6DofConstraintData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformFloatData m_rbBFrame(); public native btGeneric6DofConstraintData m_rbBFrame(btTransformFloatData setter); + + public native @ByRef btVector3FloatData m_linearUpperLimit(); public native btGeneric6DofConstraintData m_linearUpperLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearLowerLimit(); public native btGeneric6DofConstraintData m_linearLowerLimit(btVector3FloatData setter); + + public native @ByRef btVector3FloatData m_angularUpperLimit(); public native btGeneric6DofConstraintData m_angularUpperLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularLowerLimit(); public native btGeneric6DofConstraintData m_angularLowerLimit(btVector3FloatData setter); + + public native int m_useLinearReferenceFrameA(); public native btGeneric6DofConstraintData m_useLinearReferenceFrameA(int setter); + public native int m_useOffsetForConstraintFrame(); public native btGeneric6DofConstraintData m_useOffsetForConstraintFrame(int setter); +} + +public static class btGeneric6DofConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofConstraintDoubleData2 position(long position) { + return (btGeneric6DofConstraintDoubleData2)super.position(position); + } + @Override public btGeneric6DofConstraintDoubleData2 getPointer(long i) { + return new btGeneric6DofConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btGeneric6DofConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btGeneric6DofConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); + + public native @ByRef btVector3DoubleData m_linearUpperLimit(); public native btGeneric6DofConstraintDoubleData2 m_linearUpperLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearLowerLimit(); public native btGeneric6DofConstraintDoubleData2 m_linearLowerLimit(btVector3DoubleData setter); + + public native @ByRef btVector3DoubleData m_angularUpperLimit(); public native btGeneric6DofConstraintDoubleData2 m_angularUpperLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularLowerLimit(); public native btGeneric6DofConstraintDoubleData2 m_angularLowerLimit(btVector3DoubleData setter); + + public native int m_useLinearReferenceFrameA(); public native btGeneric6DofConstraintDoubleData2 m_useLinearReferenceFrameA(int setter); + public native int m_useOffsetForConstraintFrame(); public native btGeneric6DofConstraintDoubleData2 m_useOffsetForConstraintFrame(int setter); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_GENERIC_6DOF_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btSliderConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +Added by Roman Ponomarev (rponom@gmail.com) +April 04, 2008 + +TODO: + - add clamping od accumulated impulse to improve stability + - add conversion for ODE constraint solver +*/ + +// #ifndef BT_SLIDER_CONSTRAINT_H +// #define BT_SLIDER_CONSTRAINT_H + +// #include "LinearMath/btScalar.h" //for BT_USE_DOUBLE_PRECISION + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btSliderConstraintData2 btSliderConstraintData +public static final String btSliderConstraintDataName = "btSliderConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_SOFTNESS(); +public static final double SLIDER_CONSTRAINT_DEF_SOFTNESS = SLIDER_CONSTRAINT_DEF_SOFTNESS(); +public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_DAMPING(); +public static final double SLIDER_CONSTRAINT_DEF_DAMPING = SLIDER_CONSTRAINT_DEF_DAMPING(); +public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_RESTITUTION(); +public static final double SLIDER_CONSTRAINT_DEF_RESTITUTION = SLIDER_CONSTRAINT_DEF_RESTITUTION(); +public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_CFM(); +public static final double SLIDER_CONSTRAINT_DEF_CFM = SLIDER_CONSTRAINT_DEF_CFM(); + +/** enum btSliderFlags */ +public static final int + BT_SLIDER_FLAGS_CFM_DIRLIN = (1 << 0), + BT_SLIDER_FLAGS_ERP_DIRLIN = (1 << 1), + BT_SLIDER_FLAGS_CFM_DIRANG = (1 << 2), + BT_SLIDER_FLAGS_ERP_DIRANG = (1 << 3), + BT_SLIDER_FLAGS_CFM_ORTLIN = (1 << 4), + BT_SLIDER_FLAGS_ERP_ORTLIN = (1 << 5), + BT_SLIDER_FLAGS_CFM_ORTANG = (1 << 6), + BT_SLIDER_FLAGS_ERP_ORTANG = (1 << 7), + BT_SLIDER_FLAGS_CFM_LIMLIN = (1 << 8), + BT_SLIDER_FLAGS_ERP_LIMLIN = (1 << 9), + BT_SLIDER_FLAGS_CFM_LIMANG = (1 << 10), + BT_SLIDER_FLAGS_ERP_LIMANG = (1 << 11); + +@NoOffset public static class btSliderConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSliderConstraint(Pointer p) { super(p); } + + + // constructors + public btSliderConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); + public btSliderConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); + + // overrides + + // access + public native @Const @ByRef btRigidBody getRigidBodyA(); + public native @Const @ByRef btRigidBody getRigidBodyB(); + public native @Const @ByRef btTransform getCalculatedTransformA(); + public native @Const @ByRef btTransform getCalculatedTransformB(); + public native @ByRef btTransform getFrameOffsetA(); + public native @ByRef btTransform getFrameOffsetB(); + public native @Cast("btScalar") float getLowerLinLimit(); + public native void setLowerLinLimit(@Cast("btScalar") float lowerLimit); + public native @Cast("btScalar") float getUpperLinLimit(); + public native void setUpperLinLimit(@Cast("btScalar") float upperLimit); + public native @Cast("btScalar") float getLowerAngLimit(); + public native void setLowerAngLimit(@Cast("btScalar") float lowerLimit); + public native @Cast("btScalar") float getUpperAngLimit(); + public native void setUpperAngLimit(@Cast("btScalar") float upperLimit); + public native @Cast("bool") boolean getUseLinearReferenceFrameA(); + public native @Cast("btScalar") float getSoftnessDirLin(); + public native @Cast("btScalar") float getRestitutionDirLin(); + public native @Cast("btScalar") float getDampingDirLin(); + public native @Cast("btScalar") float getSoftnessDirAng(); + public native @Cast("btScalar") float getRestitutionDirAng(); + public native @Cast("btScalar") float getDampingDirAng(); + public native @Cast("btScalar") float getSoftnessLimLin(); + public native @Cast("btScalar") float getRestitutionLimLin(); + public native @Cast("btScalar") float getDampingLimLin(); + public native @Cast("btScalar") float getSoftnessLimAng(); + public native @Cast("btScalar") float getRestitutionLimAng(); + public native @Cast("btScalar") float getDampingLimAng(); + public native @Cast("btScalar") float getSoftnessOrthoLin(); + public native @Cast("btScalar") float getRestitutionOrthoLin(); + public native @Cast("btScalar") float getDampingOrthoLin(); + public native @Cast("btScalar") float getSoftnessOrthoAng(); + public native @Cast("btScalar") float getRestitutionOrthoAng(); + public native @Cast("btScalar") float getDampingOrthoAng(); + public native void setSoftnessDirLin(@Cast("btScalar") float softnessDirLin); + public native void setRestitutionDirLin(@Cast("btScalar") float restitutionDirLin); + public native void setDampingDirLin(@Cast("btScalar") float dampingDirLin); + public native void setSoftnessDirAng(@Cast("btScalar") float softnessDirAng); + public native void setRestitutionDirAng(@Cast("btScalar") float restitutionDirAng); + public native void setDampingDirAng(@Cast("btScalar") float dampingDirAng); + public native void setSoftnessLimLin(@Cast("btScalar") float softnessLimLin); + public native void setRestitutionLimLin(@Cast("btScalar") float restitutionLimLin); + public native void setDampingLimLin(@Cast("btScalar") float dampingLimLin); + public native void setSoftnessLimAng(@Cast("btScalar") float softnessLimAng); + public native void setRestitutionLimAng(@Cast("btScalar") float restitutionLimAng); + public native void setDampingLimAng(@Cast("btScalar") float dampingLimAng); + public native void setSoftnessOrthoLin(@Cast("btScalar") float softnessOrthoLin); + public native void setRestitutionOrthoLin(@Cast("btScalar") float restitutionOrthoLin); + public native void setDampingOrthoLin(@Cast("btScalar") float dampingOrthoLin); + public native void setSoftnessOrthoAng(@Cast("btScalar") float softnessOrthoAng); + public native void setRestitutionOrthoAng(@Cast("btScalar") float restitutionOrthoAng); + public native void setDampingOrthoAng(@Cast("btScalar") float dampingOrthoAng); + public native void setPoweredLinMotor(@Cast("bool") boolean onOff); + public native @Cast("bool") boolean getPoweredLinMotor(); + public native void setTargetLinMotorVelocity(@Cast("btScalar") float targetLinMotorVelocity); + public native @Cast("btScalar") float getTargetLinMotorVelocity(); + public native void setMaxLinMotorForce(@Cast("btScalar") float maxLinMotorForce); + public native @Cast("btScalar") float getMaxLinMotorForce(); + public native void setPoweredAngMotor(@Cast("bool") boolean onOff); + public native @Cast("bool") boolean getPoweredAngMotor(); + public native void setTargetAngMotorVelocity(@Cast("btScalar") float targetAngMotorVelocity); + public native @Cast("btScalar") float getTargetAngMotorVelocity(); + public native void setMaxAngMotorForce(@Cast("btScalar") float maxAngMotorForce); + public native @Cast("btScalar") float getMaxAngMotorForce(); + + public native @Cast("btScalar") float getLinearPos(); + public native @Cast("btScalar") float getAngularPos(); + + // access for ODE solver + public native @Cast("bool") boolean getSolveLinLimit(); + public native @Cast("btScalar") float getLinDepth(); + public native @Cast("bool") boolean getSolveAngLimit(); + public native @Cast("btScalar") float getAngDepth(); + // shared code used by ODE solver + public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + public native void testLinLimits(); + public native void testAngLimits(); + // access for PE Solver + public native @ByVal btVector3 getAncorInA(); + public native @ByVal btVector3 getAncorInB(); + // access for UseFrameOffset + public native @Cast("bool") boolean getUseFrameOffset(); + public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ + +public static class btSliderConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSliderConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSliderConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSliderConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSliderConstraintData position(long position) { + return (btSliderConstraintData)super.position(position); + } + @Override public btSliderConstraintData getPointer(long i) { + return new btSliderConstraintData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btSliderConstraintData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformFloatData m_rbBFrame(); public native btSliderConstraintData m_rbBFrame(btTransformFloatData setter); + + public native float m_linearUpperLimit(); public native btSliderConstraintData m_linearUpperLimit(float setter); + public native float m_linearLowerLimit(); public native btSliderConstraintData m_linearLowerLimit(float setter); + + public native float m_angularUpperLimit(); public native btSliderConstraintData m_angularUpperLimit(float setter); + public native float m_angularLowerLimit(); public native btSliderConstraintData m_angularLowerLimit(float setter); + + public native int m_useLinearReferenceFrameA(); public native btSliderConstraintData m_useLinearReferenceFrameA(int setter); + public native int m_useOffsetForConstraintFrame(); public native btSliderConstraintData m_useOffsetForConstraintFrame(int setter); +} + +public static class btSliderConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSliderConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSliderConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSliderConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSliderConstraintDoubleData position(long position) { + return (btSliderConstraintDoubleData)super.position(position); + } + @Override public btSliderConstraintDoubleData getPointer(long i) { + return new btSliderConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btSliderConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btSliderConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); + + public native double m_linearUpperLimit(); public native btSliderConstraintDoubleData m_linearUpperLimit(double setter); + public native double m_linearLowerLimit(); public native btSliderConstraintDoubleData m_linearLowerLimit(double setter); + + public native double m_angularUpperLimit(); public native btSliderConstraintDoubleData m_angularUpperLimit(double setter); + public native double m_angularLowerLimit(); public native btSliderConstraintDoubleData m_angularLowerLimit(double setter); + + public native int m_useLinearReferenceFrameA(); public native btSliderConstraintDoubleData m_useLinearReferenceFrameA(int setter); + public native int m_useOffsetForConstraintFrame(); public native btSliderConstraintDoubleData m_useOffsetForConstraintFrame(int setter); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_SLIDER_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H +// #define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btTypedConstraint.h" +// #include "btGeneric6DofConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData +public static final String btGeneric6DofSpringConstraintDataName = "btGeneric6DofSpringConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF +

+ * DOF index used in enableSpring() and setStiffness() means: + * 0 : translation X + * 1 : translation Y + * 2 : translation Z + * 3 : rotation X (3rd Euler rotational around new position of X axis, range [-PI+epsilon, PI-epsilon] ) + * 4 : rotation Y (2nd Euler rotational around new position of Y axis, range [-PI/2+epsilon, PI/2-epsilon] ) + * 5 : rotation Z (1st Euler rotational around Z axis, range [-PI+epsilon, PI-epsilon] ) */ + +@NoOffset public static class btGeneric6DofSpringConstraint extends btGeneric6DofConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpringConstraint(Pointer p) { super(p); } + + + public btGeneric6DofSpringConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); + public btGeneric6DofSpringConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameB); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB); + public native void enableSpring(int index, @Cast("bool") boolean onOff); + public native void setStiffness(int index, @Cast("btScalar") float stiffness); + public native void setDamping(int index, @Cast("btScalar") float damping); + public native void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF + public native void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF + public native void setEquilibriumPoint(int index, @Cast("btScalar") float val); + + public native @Cast("bool") boolean isSpringEnabled(int index); + + public native @Cast("btScalar") float getStiffness(int index); + + public native @Cast("btScalar") float getDamping(int index); + + public native @Cast("btScalar") float getEquilibriumPoint(int index); + + public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + + public native int calculateSerializeBufferSize(); + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +public static class btGeneric6DofSpringConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofSpringConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofSpringConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpringConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofSpringConstraintData position(long position) { + return (btGeneric6DofSpringConstraintData)super.position(position); + } + @Override public btGeneric6DofSpringConstraintData getPointer(long i) { + return new btGeneric6DofSpringConstraintData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btGeneric6DofConstraintData m_6dofData(); public native btGeneric6DofSpringConstraintData m_6dofData(btGeneric6DofConstraintData setter); + + public native int m_springEnabled(int i); public native btGeneric6DofSpringConstraintData m_springEnabled(int i, int setter); + @MemberGetter public native IntPointer m_springEnabled(); + public native float m_equilibriumPoint(int i); public native btGeneric6DofSpringConstraintData m_equilibriumPoint(int i, float setter); + @MemberGetter public native FloatPointer m_equilibriumPoint(); + public native float m_springStiffness(int i); public native btGeneric6DofSpringConstraintData m_springStiffness(int i, float setter); + @MemberGetter public native FloatPointer m_springStiffness(); + public native float m_springDamping(int i); public native btGeneric6DofSpringConstraintData m_springDamping(int i, float setter); + @MemberGetter public native FloatPointer m_springDamping(); +} + +public static class btGeneric6DofSpringConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofSpringConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofSpringConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpringConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofSpringConstraintDoubleData2 position(long position) { + return (btGeneric6DofSpringConstraintDoubleData2)super.position(position); + } + @Override public btGeneric6DofSpringConstraintDoubleData2 getPointer(long i) { + return new btGeneric6DofSpringConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + public native @ByRef btGeneric6DofConstraintDoubleData2 m_6dofData(); public native btGeneric6DofSpringConstraintDoubleData2 m_6dofData(btGeneric6DofConstraintDoubleData2 setter); + + public native int m_springEnabled(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springEnabled(int i, int setter); + @MemberGetter public native IntPointer m_springEnabled(); + public native double m_equilibriumPoint(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_equilibriumPoint(int i, double setter); + @MemberGetter public native DoublePointer m_equilibriumPoint(); + public native double m_springStiffness(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springStiffness(int i, double setter); + @MemberGetter public native DoublePointer m_springStiffness(); + public native double m_springDamping(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springDamping(int i, double setter); + @MemberGetter public native DoublePointer m_springDamping(); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer +Pros: +- Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled) +- Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring) +- Servo motor functionality +- Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision) +- Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2) + +Cons: +- It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation. +- At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.) +*/ + +/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ + +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +// #ifndef BT_GENERIC_6DOF_CONSTRAINT2_H +// #define BT_GENERIC_6DOF_CONSTRAINT2_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData +public static final String btGeneric6DofSpring2ConstraintDataName = "btGeneric6DofSpring2ConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum RotateOrder */ +public static final int + RO_XYZ = 0, + RO_XZY = 1, + RO_YXZ = 2, + RO_YZX = 3, + RO_ZXY = 4, + RO_ZYX = 5; + +@NoOffset public static class btRotationalLimitMotor2 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRotationalLimitMotor2(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btRotationalLimitMotor2(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btRotationalLimitMotor2 position(long position) { + return (btRotationalLimitMotor2)super.position(position); + } + @Override public btRotationalLimitMotor2 getPointer(long i) { + return new btRotationalLimitMotor2((Pointer)this).offsetAddress(i); + } + + // upper < lower means free + // upper == lower means locked + // upper > lower means limited + public native @Cast("btScalar") float m_loLimit(); public native btRotationalLimitMotor2 m_loLimit(float setter); + public native @Cast("btScalar") float m_hiLimit(); public native btRotationalLimitMotor2 m_hiLimit(float setter); + public native @Cast("btScalar") float m_bounce(); public native btRotationalLimitMotor2 m_bounce(float setter); + public native @Cast("btScalar") float m_stopERP(); public native btRotationalLimitMotor2 m_stopERP(float setter); + public native @Cast("btScalar") float m_stopCFM(); public native btRotationalLimitMotor2 m_stopCFM(float setter); + public native @Cast("btScalar") float m_motorERP(); public native btRotationalLimitMotor2 m_motorERP(float setter); + public native @Cast("btScalar") float m_motorCFM(); public native btRotationalLimitMotor2 m_motorCFM(float setter); + public native @Cast("bool") boolean m_enableMotor(); public native btRotationalLimitMotor2 m_enableMotor(boolean setter); + public native @Cast("btScalar") float m_targetVelocity(); public native btRotationalLimitMotor2 m_targetVelocity(float setter); + public native @Cast("btScalar") float m_maxMotorForce(); public native btRotationalLimitMotor2 m_maxMotorForce(float setter); + public native @Cast("bool") boolean m_servoMotor(); public native btRotationalLimitMotor2 m_servoMotor(boolean setter); + public native @Cast("btScalar") float m_servoTarget(); public native btRotationalLimitMotor2 m_servoTarget(float setter); + public native @Cast("bool") boolean m_enableSpring(); public native btRotationalLimitMotor2 m_enableSpring(boolean setter); + public native @Cast("btScalar") float m_springStiffness(); public native btRotationalLimitMotor2 m_springStiffness(float setter); + public native @Cast("bool") boolean m_springStiffnessLimited(); public native btRotationalLimitMotor2 m_springStiffnessLimited(boolean setter); + public native @Cast("btScalar") float m_springDamping(); public native btRotationalLimitMotor2 m_springDamping(float setter); + public native @Cast("bool") boolean m_springDampingLimited(); public native btRotationalLimitMotor2 m_springDampingLimited(boolean setter); + public native @Cast("btScalar") float m_equilibriumPoint(); public native btRotationalLimitMotor2 m_equilibriumPoint(float setter); + + public native @Cast("btScalar") float m_currentLimitError(); public native btRotationalLimitMotor2 m_currentLimitError(float setter); + public native @Cast("btScalar") float m_currentLimitErrorHi(); public native btRotationalLimitMotor2 m_currentLimitErrorHi(float setter); + public native @Cast("btScalar") float m_currentPosition(); public native btRotationalLimitMotor2 m_currentPosition(float setter); + public native int m_currentLimit(); public native btRotationalLimitMotor2 m_currentLimit(int setter); + + public btRotationalLimitMotor2() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btRotationalLimitMotor2(@Const @ByRef btRotationalLimitMotor2 limot) { super((Pointer)null); allocate(limot); } + private native void allocate(@Const @ByRef btRotationalLimitMotor2 limot); + + public native @Cast("bool") boolean isLimited(); + + public native void testLimitValue(@Cast("btScalar") float test_value); +} + +@NoOffset public static class btTranslationalLimitMotor2 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTranslationalLimitMotor2(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTranslationalLimitMotor2(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTranslationalLimitMotor2 position(long position) { + return (btTranslationalLimitMotor2)super.position(position); + } + @Override public btTranslationalLimitMotor2 getPointer(long i) { + return new btTranslationalLimitMotor2((Pointer)this).offsetAddress(i); + } + + // upper < lower means free + // upper == lower means locked + // upper > lower means limited + public native @ByRef btVector3 m_lowerLimit(); public native btTranslationalLimitMotor2 m_lowerLimit(btVector3 setter); + public native @ByRef btVector3 m_upperLimit(); public native btTranslationalLimitMotor2 m_upperLimit(btVector3 setter); + public native @ByRef btVector3 m_bounce(); public native btTranslationalLimitMotor2 m_bounce(btVector3 setter); + public native @ByRef btVector3 m_stopERP(); public native btTranslationalLimitMotor2 m_stopERP(btVector3 setter); + public native @ByRef btVector3 m_stopCFM(); public native btTranslationalLimitMotor2 m_stopCFM(btVector3 setter); + public native @ByRef btVector3 m_motorERP(); public native btTranslationalLimitMotor2 m_motorERP(btVector3 setter); + public native @ByRef btVector3 m_motorCFM(); public native btTranslationalLimitMotor2 m_motorCFM(btVector3 setter); + public native @Cast("bool") boolean m_enableMotor(int i); public native btTranslationalLimitMotor2 m_enableMotor(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_enableMotor(); + public native @Cast("bool") boolean m_servoMotor(int i); public native btTranslationalLimitMotor2 m_servoMotor(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_servoMotor(); + public native @Cast("bool") boolean m_enableSpring(int i); public native btTranslationalLimitMotor2 m_enableSpring(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_enableSpring(); + public native @ByRef btVector3 m_servoTarget(); public native btTranslationalLimitMotor2 m_servoTarget(btVector3 setter); + public native @ByRef btVector3 m_springStiffness(); public native btTranslationalLimitMotor2 m_springStiffness(btVector3 setter); + public native @Cast("bool") boolean m_springStiffnessLimited(int i); public native btTranslationalLimitMotor2 m_springStiffnessLimited(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_springStiffnessLimited(); + public native @ByRef btVector3 m_springDamping(); public native btTranslationalLimitMotor2 m_springDamping(btVector3 setter); + public native @Cast("bool") boolean m_springDampingLimited(int i); public native btTranslationalLimitMotor2 m_springDampingLimited(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_springDampingLimited(); + public native @ByRef btVector3 m_equilibriumPoint(); public native btTranslationalLimitMotor2 m_equilibriumPoint(btVector3 setter); + public native @ByRef btVector3 m_targetVelocity(); public native btTranslationalLimitMotor2 m_targetVelocity(btVector3 setter); + public native @ByRef btVector3 m_maxMotorForce(); public native btTranslationalLimitMotor2 m_maxMotorForce(btVector3 setter); + + public native @ByRef btVector3 m_currentLimitError(); public native btTranslationalLimitMotor2 m_currentLimitError(btVector3 setter); + public native @ByRef btVector3 m_currentLimitErrorHi(); public native btTranslationalLimitMotor2 m_currentLimitErrorHi(btVector3 setter); + public native @ByRef btVector3 m_currentLinearDiff(); public native btTranslationalLimitMotor2 m_currentLinearDiff(btVector3 setter); + public native int m_currentLimit(int i); public native btTranslationalLimitMotor2 m_currentLimit(int i, int setter); + @MemberGetter public native IntPointer m_currentLimit(); + + public btTranslationalLimitMotor2() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btTranslationalLimitMotor2(@Const @ByRef btTranslationalLimitMotor2 other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btTranslationalLimitMotor2 other); + + public native @Cast("bool") boolean isLimited(int limitIndex); + + public native void testLimitValue(int limitIndex, @Cast("btScalar") float test_value); +} + +/** enum bt6DofFlags2 */ +public static final int + BT_6DOF_FLAGS_CFM_STOP2 = 1, + BT_6DOF_FLAGS_ERP_STOP2 = 2, + BT_6DOF_FLAGS_CFM_MOTO2 = 4, + BT_6DOF_FLAGS_ERP_MOTO2 = 8, + BT_6DOF_FLAGS_USE_INFINITE_ERROR = (1<<16); +public static final int BT_6DOF_FLAGS_AXIS_SHIFT2 = 4; // bits per axis + +@NoOffset public static class btGeneric6DofSpring2Constraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpring2Constraint(Pointer p) { super(p); } + + + public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, rotOrder); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/); + public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB); + public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/) { super((Pointer)null); allocate(rbB, frameInB, rotOrder); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/); + public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbB, frameInB); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB); + + public native void buildJacobian(); + public native int calculateSerializeBufferSize(); + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native btRotationalLimitMotor2 getRotationalLimitMotor(int index); + public native btTranslationalLimitMotor2 getTranslationalLimitMotor(); + + // Calculates the global transform for the joint offset for body A an B, and also calculates the angle differences between the bodies. + public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + public native void calculateTransforms(); + + // Gets the global transform of the offset for body A + public native @Const @ByRef btTransform getCalculatedTransformA(); + // Gets the global transform of the offset for body B + public native @Const @ByRef btTransform getCalculatedTransformB(); + + public native @ByRef btTransform getFrameOffsetA(); + public native @ByRef btTransform getFrameOffsetB(); + + // Get the rotation axis in global coordinates ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + public native @ByVal btVector3 getAxis(int axis_index); + + // Get the relative Euler angle ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + public native @Cast("btScalar") float getAngle(int axis_index); + + // Get the relative position of the constraint pivot ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + public native @Cast("btScalar") float getRelativePivotPosition(int axis_index); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + public native void setLinearLowerLimit(@Const @ByRef btVector3 linearLower); + public native void getLinearLowerLimit(@ByRef btVector3 linearLower); + public native void setLinearUpperLimit(@Const @ByRef btVector3 linearUpper); + public native void getLinearUpperLimit(@ByRef btVector3 linearUpper); + + public native void setAngularLowerLimit(@Const @ByRef btVector3 angularLower); + + public native void setAngularLowerLimitReversed(@Const @ByRef btVector3 angularLower); + + public native void getAngularLowerLimit(@ByRef btVector3 angularLower); + + public native void getAngularLowerLimitReversed(@ByRef btVector3 angularLower); + + public native void setAngularUpperLimit(@Const @ByRef btVector3 angularUpper); + + public native void setAngularUpperLimitReversed(@Const @ByRef btVector3 angularUpper); + + public native void getAngularUpperLimit(@ByRef btVector3 angularUpper); + + public native void getAngularUpperLimitReversed(@ByRef btVector3 angularUpper); + + //first 3 are linear, next 3 are angular + + public native void setLimit(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); + + public native void setLimitReversed(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); + + public native @Cast("bool") boolean isLimited(int limitIndex); + + public native void setRotationOrder(@Cast("RotateOrder") int order); + public native @Cast("RotateOrder") int getRotationOrder(); + + public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + + public native void setBounce(int index, @Cast("btScalar") float bounce); + + public native void enableMotor(int index, @Cast("bool") boolean onOff); + public native void setServo(int index, @Cast("bool") boolean onOff); // set the type of the motor (servo or not) (the motor has to be turned on for servo also) + public native void setTargetVelocity(int index, @Cast("btScalar") float velocity); + public native void setServoTarget(int index, @Cast("btScalar") float target); + public native void setMaxMotorForce(int index, @Cast("btScalar") float force); + + public native void enableSpring(int index, @Cast("bool") boolean onOff); + public native void setStiffness(int index, @Cast("btScalar") float stiffness, @Cast("bool") boolean limitIfNeeded/*=true*/); + public native void setStiffness(int index, @Cast("btScalar") float stiffness); // if limitIfNeeded is true the system will automatically limit the stiffness in necessary situations where otherwise the spring would move unrealistically too widely + public native void setDamping(int index, @Cast("btScalar") float damping, @Cast("bool") boolean limitIfNeeded/*=true*/); + public native void setDamping(int index, @Cast("btScalar") float damping); // if limitIfNeeded is true the system will automatically limit the damping in necessary situations where otherwise the spring would blow up + public native void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF + public native void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF + public native void setEquilibriumPoint(int index, @Cast("btScalar") float val); + + //override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + //If no axis is provided, it uses the default axis for this constraint. + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public static native @Cast("btScalar") float btGetMatrixElem(@Const @ByRef btMatrix3x3 mat, int index); + public static native @Cast("bool") boolean matrixToEulerXYZ(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerXZY(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerYXZ(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerYZX(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerZXY(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerZYX(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); +} + +public static class btGeneric6DofSpring2ConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofSpring2ConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofSpring2ConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpring2ConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofSpring2ConstraintData position(long position) { + return (btGeneric6DofSpring2ConstraintData)super.position(position); + } + @Override public btGeneric6DofSpring2ConstraintData getPointer(long i) { + return new btGeneric6DofSpring2ConstraintData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btGeneric6DofSpring2ConstraintData m_rbAFrame(btTransformFloatData setter); + public native @ByRef btTransformFloatData m_rbBFrame(); public native btGeneric6DofSpring2ConstraintData m_rbBFrame(btTransformFloatData setter); + + public native @ByRef btVector3FloatData m_linearUpperLimit(); public native btGeneric6DofSpring2ConstraintData m_linearUpperLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearLowerLimit(); public native btGeneric6DofSpring2ConstraintData m_linearLowerLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearBounce(); public native btGeneric6DofSpring2ConstraintData m_linearBounce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearStopERP(); public native btGeneric6DofSpring2ConstraintData m_linearStopERP(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearStopCFM(); public native btGeneric6DofSpring2ConstraintData m_linearStopCFM(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearMotorERP(); public native btGeneric6DofSpring2ConstraintData m_linearMotorERP(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearMotorCFM(); public native btGeneric6DofSpring2ConstraintData m_linearMotorCFM(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearTargetVelocity(); public native btGeneric6DofSpring2ConstraintData m_linearTargetVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearMaxMotorForce(); public native btGeneric6DofSpring2ConstraintData m_linearMaxMotorForce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearServoTarget(); public native btGeneric6DofSpring2ConstraintData m_linearServoTarget(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearSpringStiffness(); public native btGeneric6DofSpring2ConstraintData m_linearSpringStiffness(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearSpringDamping(); public native btGeneric6DofSpring2ConstraintData m_linearSpringDamping(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintData m_linearEquilibriumPoint(btVector3FloatData setter); + public native @Cast("char") byte m_linearEnableMotor(int i); public native btGeneric6DofSpring2ConstraintData m_linearEnableMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearEnableMotor(); + public native @Cast("char") byte m_linearServoMotor(int i); public native btGeneric6DofSpring2ConstraintData m_linearServoMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearServoMotor(); + public native @Cast("char") byte m_linearEnableSpring(int i); public native btGeneric6DofSpring2ConstraintData m_linearEnableSpring(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearEnableSpring(); + public native @Cast("char") byte m_linearSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintData m_linearSpringStiffnessLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearSpringStiffnessLimited(); + public native @Cast("char") byte m_linearSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintData m_linearSpringDampingLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearSpringDampingLimited(); + public native @Cast("char") byte m_padding1(int i); public native btGeneric6DofSpring2ConstraintData m_padding1(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding1(); + + public native @ByRef btVector3FloatData m_angularUpperLimit(); public native btGeneric6DofSpring2ConstraintData m_angularUpperLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularLowerLimit(); public native btGeneric6DofSpring2ConstraintData m_angularLowerLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularBounce(); public native btGeneric6DofSpring2ConstraintData m_angularBounce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularStopERP(); public native btGeneric6DofSpring2ConstraintData m_angularStopERP(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularStopCFM(); public native btGeneric6DofSpring2ConstraintData m_angularStopCFM(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularMotorERP(); public native btGeneric6DofSpring2ConstraintData m_angularMotorERP(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularMotorCFM(); public native btGeneric6DofSpring2ConstraintData m_angularMotorCFM(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularTargetVelocity(); public native btGeneric6DofSpring2ConstraintData m_angularTargetVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularMaxMotorForce(); public native btGeneric6DofSpring2ConstraintData m_angularMaxMotorForce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularServoTarget(); public native btGeneric6DofSpring2ConstraintData m_angularServoTarget(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularSpringStiffness(); public native btGeneric6DofSpring2ConstraintData m_angularSpringStiffness(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularSpringDamping(); public native btGeneric6DofSpring2ConstraintData m_angularSpringDamping(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintData m_angularEquilibriumPoint(btVector3FloatData setter); + public native @Cast("char") byte m_angularEnableMotor(int i); public native btGeneric6DofSpring2ConstraintData m_angularEnableMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularEnableMotor(); + public native @Cast("char") byte m_angularServoMotor(int i); public native btGeneric6DofSpring2ConstraintData m_angularServoMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularServoMotor(); + public native @Cast("char") byte m_angularEnableSpring(int i); public native btGeneric6DofSpring2ConstraintData m_angularEnableSpring(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularEnableSpring(); + public native @Cast("char") byte m_angularSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintData m_angularSpringStiffnessLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularSpringStiffnessLimited(); + public native @Cast("char") byte m_angularSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintData m_angularSpringDampingLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularSpringDampingLimited(); + + public native int m_rotateOrder(); public native btGeneric6DofSpring2ConstraintData m_rotateOrder(int setter); +} + +public static class btGeneric6DofSpring2ConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofSpring2ConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofSpring2ConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpring2ConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofSpring2ConstraintDoubleData2 position(long position) { + return (btGeneric6DofSpring2ConstraintDoubleData2)super.position(position); + } + @Override public btGeneric6DofSpring2ConstraintDoubleData2 getPointer(long i) { + return new btGeneric6DofSpring2ConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); + + public native @ByRef btVector3DoubleData m_linearUpperLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearUpperLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearLowerLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearLowerLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearBounce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearBounce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearStopERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearStopERP(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearStopCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearStopCFM(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearMotorERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMotorERP(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearMotorCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMotorCFM(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearTargetVelocity(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearTargetVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearMaxMotorForce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMaxMotorForce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearServoTarget(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearServoTarget(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearSpringStiffness(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringStiffness(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearSpringDamping(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringDamping(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEquilibriumPoint(btVector3DoubleData setter); + public native @Cast("char") byte m_linearEnableMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEnableMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearEnableMotor(); + public native @Cast("char") byte m_linearServoMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearServoMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearServoMotor(); + public native @Cast("char") byte m_linearEnableSpring(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEnableSpring(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearEnableSpring(); + public native @Cast("char") byte m_linearSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringStiffnessLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearSpringStiffnessLimited(); + public native @Cast("char") byte m_linearSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringDampingLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearSpringDampingLimited(); + public native @Cast("char") byte m_padding1(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_padding1(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding1(); + + public native @ByRef btVector3DoubleData m_angularUpperLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularUpperLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularLowerLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularLowerLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularBounce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularBounce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularStopERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularStopERP(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularStopCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularStopCFM(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularMotorERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMotorERP(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularMotorCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMotorCFM(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularTargetVelocity(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularTargetVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularMaxMotorForce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMaxMotorForce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularServoTarget(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularServoTarget(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularSpringStiffness(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringStiffness(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularSpringDamping(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringDamping(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEquilibriumPoint(btVector3DoubleData setter); + public native @Cast("char") byte m_angularEnableMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEnableMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularEnableMotor(); + public native @Cast("char") byte m_angularServoMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularServoMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularServoMotor(); + public native @Cast("char") byte m_angularEnableSpring(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEnableSpring(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularEnableSpring(); + public native @Cast("char") byte m_angularSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringStiffnessLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularSpringStiffnessLimited(); + public native @Cast("char") byte m_angularSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringDampingLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularSpringDampingLimited(); + + public native int m_rotateOrder(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rotateOrder(int setter); +} + + + + + +// #endif //BT_GENERIC_6DOF_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btUniversalConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_UNIVERSAL_CONSTRAINT_H +// #define BT_UNIVERSAL_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btTypedConstraint.h" +// #include "btGeneric6DofConstraint.h" + +/** Constraint similar to ODE Universal Joint + * has 2 rotatioonal degrees of freedom, similar to Euler rotations around Z (axis 1) + * and Y (axis 2) + * Description from ODE manual : + * "Given axis 1 on body 1, and axis 2 on body 2 that is perpendicular to axis 1, it keeps them perpendicular. + * In other words, rotation of the two bodies about the direction perpendicular to the two axes will be equal." */ + +@NoOffset public static class btUniversalConstraint extends btGeneric6DofConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btUniversalConstraint(Pointer p) { super(p); } + + + // constructor + // anchor, axis1 and axis2 are in world coordinate system + // axis1 must be orthogonal to axis2 + public btUniversalConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 anchor, @Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2) { super((Pointer)null); allocate(rbA, rbB, anchor, axis1, axis2); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 anchor, @Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + // access + public native @Const @ByRef btVector3 getAnchor(); + public native @Const @ByRef btVector3 getAnchor2(); + public native @Const @ByRef btVector3 getAxis1(); + public native @Const @ByRef btVector3 getAxis2(); + public native @Cast("btScalar") float getAngle1(); + public native @Cast("btScalar") float getAngle2(); + // limits + public native void setUpperLimit(@Cast("btScalar") float ang1max, @Cast("btScalar") float ang2max); + public native void setLowerLimit(@Cast("btScalar") float ang1min, @Cast("btScalar") float ang2min); + + public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); +} + +// #endif // BT_UNIVERSAL_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btHinge2Constraint.h + +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_HINGE2_CONSTRAINT_H +// #define BT_HINGE2_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btTypedConstraint.h" +// #include "btGeneric6DofSpring2Constraint.h" + +// Constraint similar to ODE Hinge2 Joint +// has 3 degrees of frredom: +// 2 rotational degrees of freedom, similar to Euler rotations around Z (axis 1) and X (axis 2) +// 1 translational (along axis Z) with suspension spring + +@NoOffset public static class btHinge2Constraint extends btGeneric6DofSpring2Constraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHinge2Constraint(Pointer p) { super(p); } + + + // constructor + // anchor, axis1 and axis2 are in world coordinate system + // axis1 must be orthogonal to axis2 + public btHinge2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @ByRef btVector3 anchor, @ByRef btVector3 axis1, @ByRef btVector3 axis2) { super((Pointer)null); allocate(rbA, rbB, anchor, axis1, axis2); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @ByRef btVector3 anchor, @ByRef btVector3 axis1, @ByRef btVector3 axis2); + // access + public native @Const @ByRef btVector3 getAnchor(); + public native @Const @ByRef btVector3 getAnchor2(); + public native @Const @ByRef btVector3 getAxis1(); + public native @Const @ByRef btVector3 getAxis2(); + public native @Cast("btScalar") float getAngle1(); + public native @Cast("btScalar") float getAngle2(); + // limits + public native void setUpperLimit(@Cast("btScalar") float ang1max); + public native void setLowerLimit(@Cast("btScalar") float ang1min); +} + +// #endif // BT_HINGE2_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGearConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2012 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GEAR_CONSTRAINT_H +// #define BT_GEAR_CONSTRAINT_H + +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGearConstraintData btGearConstraintFloatData +public static final String btGearConstraintDataName = "btGearConstraintFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/**The btGeatConstraint will couple the angular velocity for two bodies around given local axis and ratio. + * See Bullet/Demos/ConstraintDemo for an example use. */ +@NoOffset public static class btGearConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGearConstraint(Pointer p) { super(p); } + + public btGearConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("btScalar") float ratio/*=1.f*/) { super((Pointer)null); allocate(rbA, rbB, axisInA, axisInB, ratio); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("btScalar") float ratio/*=1.f*/); + public btGearConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, axisInA, axisInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); + + /**internal method used by the constraint solver, don't use them directly */ + + /**internal method used by the constraint solver, don't use them directly */ + + public native void setAxisA(@ByRef btVector3 axisA); + public native void setAxisB(@ByRef btVector3 axisB); + public native void setRatio(@Cast("btScalar") float ratio); + public native @Const @ByRef btVector3 getAxisA(); + public native @Const @ByRef btVector3 getAxisB(); + public native @Cast("btScalar") float getRatio(); + + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +public static class btGearConstraintFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGearConstraintFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGearConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGearConstraintFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGearConstraintFloatData position(long position) { + return (btGearConstraintFloatData)super.position(position); + } + @Override public btGearConstraintFloatData getPointer(long i) { + return new btGearConstraintFloatData((Pointer)this).offsetAddress(i); + } + + + + public native @ByRef btVector3FloatData m_axisInA(); public native btGearConstraintFloatData m_axisInA(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_axisInB(); public native btGearConstraintFloatData m_axisInB(btVector3FloatData setter); + + public native float m_ratio(); public native btGearConstraintFloatData m_ratio(float setter); + public native @Cast("char") byte m_padding(int i); public native btGearConstraintFloatData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} + +public static class btGearConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGearConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGearConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGearConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGearConstraintDoubleData position(long position) { + return (btGearConstraintDoubleData)super.position(position); + } + @Override public btGearConstraintDoubleData getPointer(long i) { + return new btGearConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + + public native @ByRef btVector3DoubleData m_axisInA(); public native btGearConstraintDoubleData m_axisInA(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_axisInB(); public native btGearConstraintDoubleData m_axisInB(btVector3DoubleData setter); + + public native double m_ratio(); public native btGearConstraintDoubleData m_ratio(double setter); +} + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_GEAR_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btFixedConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_FIXED_CONSTRAINT_H +// #define BT_FIXED_CONSTRAINT_H + +// #include "btGeneric6DofSpring2Constraint.h" + +public static class btFixedConstraint extends btGeneric6DofSpring2Constraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btFixedConstraint(Pointer p) { super(p); } + + public btFixedConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB); +} + +// #endif //BT_FIXED_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btConstraintSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONSTRAINT_SOLVER_H +// #define BT_CONSTRAINT_SOLVER_H + +// #include "LinearMath/btScalar.h" +@Opaque public static class btStackAlloc extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btStackAlloc() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStackAlloc(Pointer p) { super(p); } +} +/** btConstraintSolver provides solver interface */ + +/** enum btConstraintSolverType */ +public static final int + BT_SEQUENTIAL_IMPULSE_SOLVER = 1, + BT_MLCP_SOLVER = 2, + BT_NNCG_SOLVER = 4, + BT_MULTIBODY_SOLVER = 8, + BT_BLOCK_SOLVER = 16; + +public static class btConstraintSolver extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintSolver(Pointer p) { super(p); } + + + public native void prepareSolve(int arg0, int arg1); + + /**solve a group of constraints */ + public native @Cast("btScalar") float solveGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + public native @Cast("btScalar") float solveGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + + public native void allSolved(@Const @ByRef btContactSolverInfo arg0, btIDebugDraw arg1); + + /**clear internal cached data and reset random seed */ + public native void reset(); + + public native @Cast("btConstraintSolverType") int getSolverType(); +} + +// #endif //BT_CONSTRAINT_SOLVER_H + + +// Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H +// #define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" +// #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" +// #include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" +// #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" + +@NoOffset public static class btSolverAnalyticsData extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverAnalyticsData(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSolverAnalyticsData(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSolverAnalyticsData position(long position) { + return (btSolverAnalyticsData)super.position(position); + } + @Override public btSolverAnalyticsData getPointer(long i) { + return new btSolverAnalyticsData((Pointer)this).offsetAddress(i); + } + + public btSolverAnalyticsData() { super((Pointer)null); allocate(); } + private native void allocate(); + public native int m_islandId(); public native btSolverAnalyticsData m_islandId(int setter); + public native int m_numBodies(); public native btSolverAnalyticsData m_numBodies(int setter); + public native int m_numContactManifolds(); public native btSolverAnalyticsData m_numContactManifolds(int setter); + public native int m_numSolverCalls(); public native btSolverAnalyticsData m_numSolverCalls(int setter); + public native int m_numIterationsUsed(); public native btSolverAnalyticsData m_numIterationsUsed(int setter); + public native double m_remainingLeastSquaresResidual(); public native btSolverAnalyticsData m_remainingLeastSquaresResidual(double setter); +} + +/**The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (iterative LCP) method. */ +@NoOffset public static class btSequentialImpulseConstraintSolver extends btConstraintSolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSequentialImpulseConstraintSolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSequentialImpulseConstraintSolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSequentialImpulseConstraintSolver position(long position) { + return (btSequentialImpulseConstraintSolver)super.position(position); + } + @Override public btSequentialImpulseConstraintSolver getPointer(long i) { + return new btSequentialImpulseConstraintSolver((Pointer)this).offsetAddress(i); + } + + + public btSequentialImpulseConstraintSolver() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("btScalar") float solveGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + public native @Cast("btScalar") float solveGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + + /**clear internal cached data and reset random seed */ + public native void reset(); + + public native @Cast("unsigned long") long btRand2(); + + public native int btRandInt2(int n); + + public native void setRandSeed(@Cast("unsigned long") long seed); + public native @Cast("unsigned long") long getRandSeed(); + + public native @Cast("btConstraintSolverType") int getSolverType(); + + + + /**Various implementations of solving a single constraint row using a generic equality constraint, using scalar reference, SSE2 or SSE4 */ + + /**Various implementations of solving a single constraint row using an inequality (lower limit) constraint, using scalar reference, SSE2 or SSE4 */ + public native @ByRef btSolverAnalyticsData m_analyticsData(); public native btSequentialImpulseConstraintSolver m_analyticsData(btSolverAnalyticsData setter); +} + +// #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H + + +// Parsed from BulletDynamics/Vehicle/btVehicleRaycaster.h + +/* + * Copyright (c) 2005 Erwin Coumans http://bulletphysics.org + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies. + * Erwin Coumans makes no representations about the suitability + * of this software for any purpose. + * It is provided "as is" without express or implied warranty. +*/ +// #ifndef BT_VEHICLE_RAYCASTER_H +// #define BT_VEHICLE_RAYCASTER_H + +// #include "LinearMath/btVector3.h" + +/** btVehicleRaycaster is provides interface for between vehicle simulation and raycasting */ +public static class btVehicleRaycaster extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVehicleRaycaster(Pointer p) { super(p); } + + @NoOffset public static class btVehicleRaycasterResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVehicleRaycasterResult(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVehicleRaycasterResult(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVehicleRaycasterResult position(long position) { + return (btVehicleRaycasterResult)super.position(position); + } + @Override public btVehicleRaycasterResult getPointer(long i) { + return new btVehicleRaycasterResult((Pointer)this).offsetAddress(i); + } + + public btVehicleRaycasterResult() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @ByRef btVector3 m_hitPointInWorld(); public native btVehicleRaycasterResult m_hitPointInWorld(btVector3 setter); + public native @ByRef btVector3 m_hitNormalInWorld(); public native btVehicleRaycasterResult m_hitNormalInWorld(btVector3 setter); + public native @Cast("btScalar") float m_distFraction(); public native btVehicleRaycasterResult m_distFraction(float setter); + } + + public native Pointer castRay(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @ByRef btVehicleRaycasterResult result); +} + +// #endif //BT_VEHICLE_RAYCASTER_H + + +// Parsed from BulletDynamics/Vehicle/btWheelInfo.h + +/* + * Copyright (c) 2005 Erwin Coumans https://bulletphysics.org + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies. + * Erwin Coumans makes no representations about the suitability + * of this software for any purpose. + * It is provided "as is" without express or implied warranty. +*/ +// #ifndef BT_WHEEL_INFO_H +// #define BT_WHEEL_INFO_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" + +public static class btWheelInfoConstructionInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btWheelInfoConstructionInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btWheelInfoConstructionInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btWheelInfoConstructionInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btWheelInfoConstructionInfo position(long position) { + return (btWheelInfoConstructionInfo)super.position(position); + } + @Override public btWheelInfoConstructionInfo getPointer(long i) { + return new btWheelInfoConstructionInfo((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_chassisConnectionCS(); public native btWheelInfoConstructionInfo m_chassisConnectionCS(btVector3 setter); + public native @ByRef btVector3 m_wheelDirectionCS(); public native btWheelInfoConstructionInfo m_wheelDirectionCS(btVector3 setter); + public native @ByRef btVector3 m_wheelAxleCS(); public native btWheelInfoConstructionInfo m_wheelAxleCS(btVector3 setter); + public native @Cast("btScalar") float m_suspensionRestLength(); public native btWheelInfoConstructionInfo m_suspensionRestLength(float setter); + public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btWheelInfoConstructionInfo m_maxSuspensionTravelCm(float setter); + public native @Cast("btScalar") float m_wheelRadius(); public native btWheelInfoConstructionInfo m_wheelRadius(float setter); + + public native @Cast("btScalar") float m_suspensionStiffness(); public native btWheelInfoConstructionInfo m_suspensionStiffness(float setter); + public native @Cast("btScalar") float m_wheelsDampingCompression(); public native btWheelInfoConstructionInfo m_wheelsDampingCompression(float setter); + public native @Cast("btScalar") float m_wheelsDampingRelaxation(); public native btWheelInfoConstructionInfo m_wheelsDampingRelaxation(float setter); + public native @Cast("btScalar") float m_frictionSlip(); public native btWheelInfoConstructionInfo m_frictionSlip(float setter); + public native @Cast("btScalar") float m_maxSuspensionForce(); public native btWheelInfoConstructionInfo m_maxSuspensionForce(float setter); + public native @Cast("bool") boolean m_bIsFrontWheel(); public native btWheelInfoConstructionInfo m_bIsFrontWheel(boolean setter); +} + +/** btWheelInfo contains information per wheel about friction and suspension. */ +@NoOffset public static class btWheelInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btWheelInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btWheelInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btWheelInfo position(long position) { + return (btWheelInfo)super.position(position); + } + @Override public btWheelInfo getPointer(long i) { + return new btWheelInfo((Pointer)this).offsetAddress(i); + } + + public static class RaycastInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public RaycastInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public RaycastInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RaycastInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public RaycastInfo position(long position) { + return (RaycastInfo)super.position(position); + } + @Override public RaycastInfo getPointer(long i) { + return new RaycastInfo((Pointer)this).offsetAddress(i); + } + + //set by raycaster + public native @ByRef btVector3 m_contactNormalWS(); public native RaycastInfo m_contactNormalWS(btVector3 setter); //contactnormal + public native @ByRef btVector3 m_contactPointWS(); public native RaycastInfo m_contactPointWS(btVector3 setter); //raycast hitpoint + public native @Cast("btScalar") float m_suspensionLength(); public native RaycastInfo m_suspensionLength(float setter); + public native @ByRef btVector3 m_hardPointWS(); public native RaycastInfo m_hardPointWS(btVector3 setter); //raycast starting point + public native @ByRef btVector3 m_wheelDirectionWS(); public native RaycastInfo m_wheelDirectionWS(btVector3 setter); //direction in worldspace + public native @ByRef btVector3 m_wheelAxleWS(); public native RaycastInfo m_wheelAxleWS(btVector3 setter); // axle in worldspace + public native @Cast("bool") boolean m_isInContact(); public native RaycastInfo m_isInContact(boolean setter); + public native Pointer m_groundObject(); public native RaycastInfo m_groundObject(Pointer setter); //could be general void* ptr + } + + public native @ByRef RaycastInfo m_raycastInfo(); public native btWheelInfo m_raycastInfo(RaycastInfo setter); + + public native @ByRef btTransform m_worldTransform(); public native btWheelInfo m_worldTransform(btTransform setter); + + public native @ByRef btVector3 m_chassisConnectionPointCS(); public native btWheelInfo m_chassisConnectionPointCS(btVector3 setter); //const + public native @ByRef btVector3 m_wheelDirectionCS(); public native btWheelInfo m_wheelDirectionCS(btVector3 setter); //const + public native @ByRef btVector3 m_wheelAxleCS(); public native btWheelInfo m_wheelAxleCS(btVector3 setter); // const or modified by steering + public native @Cast("btScalar") float m_suspensionRestLength1(); public native btWheelInfo m_suspensionRestLength1(float setter); //const + public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btWheelInfo m_maxSuspensionTravelCm(float setter); + public native @Cast("btScalar") float getSuspensionRestLength(); + public native @Cast("btScalar") float m_wheelsRadius(); public native btWheelInfo m_wheelsRadius(float setter); //const + public native @Cast("btScalar") float m_suspensionStiffness(); public native btWheelInfo m_suspensionStiffness(float setter); //const + public native @Cast("btScalar") float m_wheelsDampingCompression(); public native btWheelInfo m_wheelsDampingCompression(float setter); //const + public native @Cast("btScalar") float m_wheelsDampingRelaxation(); public native btWheelInfo m_wheelsDampingRelaxation(float setter); //const + public native @Cast("btScalar") float m_frictionSlip(); public native btWheelInfo m_frictionSlip(float setter); + public native @Cast("btScalar") float m_steering(); public native btWheelInfo m_steering(float setter); + public native @Cast("btScalar") float m_rotation(); public native btWheelInfo m_rotation(float setter); + public native @Cast("btScalar") float m_deltaRotation(); public native btWheelInfo m_deltaRotation(float setter); + public native @Cast("btScalar") float m_rollInfluence(); public native btWheelInfo m_rollInfluence(float setter); + public native @Cast("btScalar") float m_maxSuspensionForce(); public native btWheelInfo m_maxSuspensionForce(float setter); + + public native @Cast("btScalar") float m_engineForce(); public native btWheelInfo m_engineForce(float setter); + + public native @Cast("btScalar") float m_brake(); public native btWheelInfo m_brake(float setter); + + public native @Cast("bool") boolean m_bIsFrontWheel(); public native btWheelInfo m_bIsFrontWheel(boolean setter); + + public native Pointer m_clientInfo(); public native btWheelInfo m_clientInfo(Pointer setter); //can be used to store pointer to sync transforms... + + public btWheelInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btWheelInfo(@ByRef btWheelInfoConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@ByRef btWheelInfoConstructionInfo ci); + + public native void updateWheel(@Const @ByRef btRigidBody chassis, @ByRef RaycastInfo raycastInfo); + + public native @Cast("btScalar") float m_clippedInvContactDotSuspension(); public native btWheelInfo m_clippedInvContactDotSuspension(float setter); + public native @Cast("btScalar") float m_suspensionRelativeVelocity(); public native btWheelInfo m_suspensionRelativeVelocity(float setter); + //calculated by suspension + public native @Cast("btScalar") float m_wheelsSuspensionForce(); public native btWheelInfo m_wheelsSuspensionForce(float setter); + public native @Cast("btScalar") float m_skidInfo(); public native btWheelInfo m_skidInfo(float setter); +} + +// #endif //BT_WHEEL_INFO_H + + +// Parsed from BulletDynamics/Vehicle/btRaycastVehicle.h + +/* + * Copyright (c) 2005 Erwin Coumans https://bulletphysics.org + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies. + * Erwin Coumans makes no representations about the suitability + * of this software for any purpose. + * It is provided "as is" without express or implied warranty. +*/ +// #ifndef BT_RAYCASTVEHICLE_H +// #define BT_RAYCASTVEHICLE_H + +// #include "BulletDynamics/Dynamics/btRigidBody.h" +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +// #include "btVehicleRaycaster.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btWheelInfo.h" +// #include "BulletDynamics/Dynamics/btActionInterface.h" + +//class btVehicleTuning; + +/**rayCast vehicle, very special constraint that turn a rigidbody into a vehicle. */ +@NoOffset public static class btRaycastVehicle extends btActionInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRaycastVehicle(Pointer p) { super(p); } + + @NoOffset public static class btVehicleTuning extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVehicleTuning(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVehicleTuning(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVehicleTuning position(long position) { + return (btVehicleTuning)super.position(position); + } + @Override public btVehicleTuning getPointer(long i) { + return new btVehicleTuning((Pointer)this).offsetAddress(i); + } + + public btVehicleTuning() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float m_suspensionStiffness(); public native btVehicleTuning m_suspensionStiffness(float setter); + public native @Cast("btScalar") float m_suspensionCompression(); public native btVehicleTuning m_suspensionCompression(float setter); + public native @Cast("btScalar") float m_suspensionDamping(); public native btVehicleTuning m_suspensionDamping(float setter); + public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btVehicleTuning m_maxSuspensionTravelCm(float setter); + public native @Cast("btScalar") float m_frictionSlip(); public native btVehicleTuning m_frictionSlip(float setter); + public native @Cast("btScalar") float m_maxSuspensionForce(); public native btVehicleTuning m_maxSuspensionForce(float setter); + } + //constructor to create a car from an existing rigidbody + public btRaycastVehicle(@Const @ByRef btVehicleTuning tuning, btRigidBody chassis, btVehicleRaycaster raycaster) { super((Pointer)null); allocate(tuning, chassis, raycaster); } + private native void allocate(@Const @ByRef btVehicleTuning tuning, btRigidBody chassis, btVehicleRaycaster raycaster); + + /**btActionInterface interface */ + public native void updateAction(btCollisionWorld collisionWorld, @Cast("btScalar") float step); + + /**btActionInterface interface */ + public native void debugDraw(btIDebugDraw debugDrawer); + + public native @Const @ByRef btTransform getChassisWorldTransform(); + + public native @Cast("btScalar") float rayCast(@ByRef btWheelInfo wheel); + + public native void updateVehicle(@Cast("btScalar") float step); + + public native void resetSuspension(); + + public native @Cast("btScalar") float getSteeringValue(int wheel); + + public native void setSteeringValue(@Cast("btScalar") float steering, int wheel); + + public native void applyEngineForce(@Cast("btScalar") float force, int wheel); + + public native @Const @ByRef btTransform getWheelTransformWS(int wheelIndex); + + public native void updateWheelTransform(int wheelIndex, @Cast("bool") boolean interpolatedTransform/*=true*/); + public native void updateWheelTransform(int wheelIndex); + + // void setRaycastWheelInfo( int wheelIndex , bool isInContact, const btVector3& hitPoint, const btVector3& hitNormal,btScalar depth); + + public native @ByRef btWheelInfo addWheel(@Const @ByRef btVector3 connectionPointCS0, @Const @ByRef btVector3 wheelDirectionCS0, @Const @ByRef btVector3 wheelAxleCS, @Cast("btScalar") float suspensionRestLength, @Cast("btScalar") float wheelRadius, @Const @ByRef btVehicleTuning tuning, @Cast("bool") boolean isFrontWheel); + + public native int getNumWheels(); + + + + public native @ByRef btWheelInfo getWheelInfo(int index); + + public native void updateWheelTransformsWS(@ByRef btWheelInfo wheel, @Cast("bool") boolean interpolatedTransform/*=true*/); + public native void updateWheelTransformsWS(@ByRef btWheelInfo wheel); + + public native void setBrake(@Cast("btScalar") float brake, int wheelIndex); + + public native void setPitchControl(@Cast("btScalar") float pitch); + + public native void updateSuspension(@Cast("btScalar") float deltaTime); + + public native void updateFriction(@Cast("btScalar") float timeStep); + + public native btRigidBody getRigidBody(); + + public native int getRightAxis(); + public native int getUpAxis(); + + public native int getForwardAxis(); + + /**Worldspace forward vector */ + public native @ByVal btVector3 getForwardVector(); + + /**Velocity of vehicle (positive if velocity vector has same direction as foward vector) */ + public native @Cast("btScalar") float getCurrentSpeedKmHour(); + + public native void setCoordinateSystem(int rightIndex, int upIndex, int forwardIndex); + + /**backwards compatibility */ + public native int getUserConstraintType(); + + public native void setUserConstraintType(int userConstraintType); + + public native void setUserConstraintId(int uid); + + public native int getUserConstraintId(); +} + +@NoOffset public static class btDefaultVehicleRaycaster extends btVehicleRaycaster { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultVehicleRaycaster(Pointer p) { super(p); } + + public btDefaultVehicleRaycaster(btDynamicsWorld world) { super((Pointer)null); allocate(world); } + private native void allocate(btDynamicsWorld world); + + public native Pointer castRay(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @ByRef btVehicleRaycasterResult result); +} + +// #endif //BT_RAYCASTVEHICLE_H + + +} diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java new file mode 100644 index 00000000000..129fd597fd5 --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -0,0 +1,104 @@ +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +@Properties( + inherit = BulletCollision.class, + value = { + @Platform( + include = { + "LinearMath/btAlignedObjectArray.h", + "BulletDynamics/Dynamics/btRigidBody.h", + "BulletDynamics/Dynamics/btDynamicsWorld.h", + "BulletDynamics/ConstraintSolver/btContactSolverInfo.h", + "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h", + "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h", + "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h", + "BulletDynamics/ConstraintSolver/btHingeConstraint.h", + "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h", + "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h", + "BulletDynamics/ConstraintSolver/btSliderConstraint.h", + "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h", + "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h", + "BulletDynamics/ConstraintSolver/btUniversalConstraint.h", + "BulletDynamics/ConstraintSolver/btHinge2Constraint.h", + "BulletDynamics/ConstraintSolver/btGearConstraint.h", + "BulletDynamics/ConstraintSolver/btFixedConstraint.h", + "BulletDynamics/ConstraintSolver/btConstraintSolver.h", + "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h", + "BulletDynamics/Vehicle/btVehicleRaycaster.h", + "BulletDynamics/Vehicle/btWheelInfo.h", + "BulletDynamics/Vehicle/btRaycastVehicle.h", + }, + link = "BulletDynamics" + ) + }, + target = "org.bytedeco.bullet.BulletDynamics" +) +public class BulletDynamics implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + public void map(InfoMap infoMap) { + infoMap + .put(new Info("btRigidBodyData") + .cppText("#define btRigidBodyData btRigidBodyFloatData")) + .put(new Info("defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0") + .define(false)) + .put(new Info("btAlignedObjectArray") + .pointerTypes("btAlignedObjectArray_btRigidBodyPointer")) + .put(new Info("IN_PARALLELL_SOLVER").define(false)) + .put(new Info("BT_BACKWARDS_COMPATIBLE_SERIALIZATION").define(true)) + .put(new Info("btConstraintInfo1").skip()) + .put(new Info("btConstraintInfo2").skip()) + .put(new Info("btPoint2PointConstraintFloatData::m_typeConstraintData").skip()) + .put(new Info("btPoint2PointConstraintDoubleData::m_typeConstraintData").skip()) + .put(new Info("btPoint2PointConstraintDoubleData2::m_typeConstraintData").skip()) + .put(new Info("btPoint2PointConstraintData2") + .cppText("#define btPoint2PointConstraintData2 " + + "btPoint2PointConstraintDoubleData2")) + .put(new Info("btHingeConstraintFloatData::m_typeConstraintData").skip()) + .put(new Info("btHingeConstraintDoubleData::m_typeConstraintData").skip()) + .put(new Info("btHingeConstraintDoubleData2::m_typeConstraintData").skip()) + .put(new Info("btHingeConstraintData") + .cppText("#define btHingeConstraintData " + + "btHingeConstraintFloatData")) + .put(new Info("btConeTwistConstraint::solveConstraintObsolete").skip()) + .put(new Info("btConeTwistConstraintData::m_typeConstraintData").skip()) + .put(new Info("btConeTwistConstraintDoubleData::m_typeConstraintData").skip()) + .put(new Info("btConeTwistConstraintData2") + .cppText("#define btConeTwistConstraintData2 " + + "btConeTwistConstraintData")) + .put(new Info("btGeneric6DofConstraintData::m_typeConstraintData").skip()) + .put(new Info("btGeneric6DofConstraintDoubleData2::m_typeConstraintData").skip()) + .put(new Info("btGeneric6DofConstraintData2") + .cppText("#define btGeneric6DofConstraintData2 " + + "btGeneric6DofConstraintDoubleData2")) + .put(new Info("btSliderConstraintData::m_typeConstraintData").skip()) + .put(new Info("btSliderConstraintDoubleData::m_typeConstraintData").skip()) + .put(new Info("btSliderConstraintData2") + .cppText("#define btSliderConstraintData2 " + + "btSliderConstraintDoubleData2")) + .put(new Info("btGeneric6DofSpringConstraintData2") + .cppText("#define btGeneric6DofSpringConstraintData2 " + + "btGeneric6DofSpringConstraintData")) + .put(new Info("btGeneric6DofSpring2ConstraintData::m_typeConstraintData").skip()) + .put(new Info("btGeneric6DofSpring2ConstraintDoubleData2::" + + "m_typeConstraintData").skip()) + .put(new Info("btGeneric6DofSpring2ConstraintData2") + .cppText("#define btGeneric6DofSpring2ConstraintData2 " + + "btGeneric6DofSpring2ConstraintData")) + .put(new Info("btGearConstraintFloatData::m_typeConstraintData").skip()) + .put(new Info("btGearConstraintDoubleData::m_typeConstraintData").skip()) + .put(new Info("btGearConstraintData") + .cppText("#define btGearConstraintData btGearConstraintFloatData")) + .put(new Info("btSingleConstraintRowSolver").skip()) + .put(new Info("btRaycastVehicle::m_wheelInfo").skip()) + ; + } +} diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 93ef34d1446..c38d97bbe47 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -3,4 +3,5 @@ exports org.bytedeco.bullet.presets; exports org.bytedeco.bullet.LinearMath; exports org.bytedeco.bullet.BulletCollision; + exports org.bytedeco.bullet.BulletDynamics; } From add934ffe3294c50dd7a292b59f631f8ac1f0a3a Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 14 Feb 2022 13:26:15 +0800 Subject: [PATCH 07/81] Extract each bullet's class into a separate file Streamline importing of the generated classes. --- .../org/bytedeco/bullet/BulletCollision.java | 5615 ----------------- .../CalculateCombinedCallback.java | 27 + .../BulletCollision/ContactAddedCallback.java | 24 + .../BulletCollision/bt32BitAxisSweep3.java | 29 + .../btActivatingCollisionAlgorithm.java | 23 + .../bullet/BulletCollision/btAxisSweep3.java | 29 + .../BulletCollision/btBU_Simplex1to4.java | 71 + .../bullet/BulletCollision/btBoxShape.java | 66 + .../btBroadphaseAabbCallback.java | 23 + .../btBroadphaseInterface.java | 49 + .../BulletCollision/btBroadphasePair.java | 45 + .../btBroadphasePairSortPredicate.java | 44 + .../BulletCollision/btBroadphaseProxy.java | 78 + .../btBroadphaseRayCallback.java | 27 + .../BulletCollision/btBvhSubtreeInfo.java | 49 + .../BulletCollision/btBvhSubtreeInfoData.java | 42 + .../btBvhTriangleMeshShape.java | 82 + .../BulletCollision/btCapsuleShape.java | 59 + .../BulletCollision/btCapsuleShapeData.java | 41 + .../BulletCollision/btCapsuleShapeX.java | 29 + .../BulletCollision/btCapsuleShapeZ.java | 29 + .../btCharIndexTripletData.java | 37 + .../BulletCollision/btCollisionAlgorithm.java | 22 + .../btCollisionAlgorithmConstructionInfo.java | 21 + .../btCollisionAlgorithmCreateFunc.java | 38 + .../btCollisionConfiguration.java | 21 + .../btCollisionDispatcher.java | 78 + .../BulletCollision/btCollisionObject.java | 233 + .../btCollisionObjectDoubleData.java | 67 + .../btCollisionObjectFloatData.java | 65 + .../btCollisionObjectWrapper.java | 21 + .../BulletCollision/btCollisionShape.java | 89 + .../BulletCollision/btCollisionShapeData.java | 41 + .../BulletCollision/btCollisionWorld.java | 287 + .../BulletCollision/btCompoundShape.java | 97 + .../BulletCollision/btCompoundShapeChild.java | 40 + .../btCompoundShapeChildData.java | 41 + .../BulletCollision/btCompoundShapeData.java | 43 + .../BulletCollision/btConcaveShape.java | 29 + .../bullet/BulletCollision/btConeShape.java | 54 + .../BulletCollision/btConeShapeData.java | 41 + .../bullet/BulletCollision/btConeShapeX.java | 30 + .../bullet/BulletCollision/btConeShapeZ.java | 30 + .../BulletCollision/btConstraintRow.java | 44 + .../BulletCollision/btConvexHullShape.java | 86 + .../btConvexHullShapeData.java | 46 + .../btConvexInternalAabbCachingShape.java | 28 + .../btConvexInternalShape.java | 67 + .../btConvexInternalShapeData.java | 44 + .../btConvexPenetrationDepthSolver.java | 21 + .../BulletCollision/btConvexPolyhedron.java | 21 + .../bullet/BulletCollision/btConvexShape.java | 21 + .../btConvexTriangleMeshShape.java | 58 + .../BulletCollision/btCylinderShape.java | 61 + .../BulletCollision/btCylinderShapeData.java | 41 + .../BulletCollision/btCylinderShapeX.java | 33 + .../BulletCollision/btCylinderShapeZ.java | 33 + .../bullet/BulletCollision/btDbvt.java | 23 + .../BulletCollision/btDbvtBroadphase.java | 100 + .../btDefaultCollisionConfiguration.java | 60 + .../btDefaultCollisionConstructionInfo.java | 40 + .../btDiscreteCollisionDetectorInterface.java | 67 + .../bullet/BulletCollision/btDispatcher.java | 50 + .../BulletCollision/btDispatcherInfo.java | 50 + .../bullet/BulletCollision/btEmptyShape.java | 48 + .../btHashedOverlappingPairCache.java | 71 + .../bullet/BulletCollision/btIndexedMesh.java | 54 + .../BulletCollision/btIntIndexData.java | 35 + .../btInternalTriangleIndexCallback.java | 23 + .../BulletCollision/btManifoldPoint.java | 95 + .../BulletCollision/btManifoldResult.java | 69 + .../BulletCollision/btMeshPartData.java | 48 + .../BulletCollision/btMultiSphereShape.java | 52 + .../btMultiSphereShapeData.java | 42 + .../BulletCollision/btNearCallback.java | 24 + .../btNodeOverlapCallback.java | 24 + .../BulletCollision/btNullPairCache.java | 63 + .../BulletCollision/btOptimizedBvh.java | 48 + .../BulletCollision/btOptimizedBvhNode.java | 52 + .../btOptimizedBvhNodeDoubleData.java | 41 + .../btOptimizedBvhNodeFloatData.java | 41 + .../BulletCollision/btOverlapCallback.java | 24 + .../btOverlapFilterCallback.java | 24 + .../btOverlappingPairCache.java | 48 + .../btOverlappingPairCallback.java | 29 + .../BulletCollision/btPersistentManifold.java | 22 + .../btPolyhedralConvexAabbCachingShape.java | 30 + .../btPolyhedralConvexShape.java | 49 + .../BulletCollision/btPoolAllocator.java | 21 + .../BulletCollision/btPositionAndRadius.java | 36 + .../BulletCollision/btQuantizedBvh.java | 100 + .../btQuantizedBvhDoubleData.java | 47 + .../btQuantizedBvhFloatData.java | 47 + .../BulletCollision/btQuantizedBvhNode.java | 49 + .../btQuantizedBvhNodeData.java | 40 + .../bullet/BulletCollision/btRigidBody.java | 21 + .../btScaledBvhTriangleMeshShape.java | 44 + .../btScaledTriangleMeshShapeData.java | 38 + .../BulletCollision/btShortIntIndexData.java | 37 + .../btShortIntIndexTripletData.java | 38 + .../BulletCollision/btSimpleBroadphase.java | 61 + .../btSimpleBroadphaseProxy.java | 43 + .../btSortedOverlappingPairCache.java | 69 + .../bullet/BulletCollision/btSphereShape.java | 45 + .../btSphereSphereCollisionAlgorithm.java | 56 + .../BulletCollision/btStaticPlaneShape.java | 47 + .../btStaticPlaneShapeData.java | 42 + .../BulletCollision/btStorageResult.java | 27 + .../btStridingMeshInterface.java | 76 + .../btStridingMeshInterfaceData.java | 41 + .../BulletCollision/btTriangleCallback.java | 25 + .../btTriangleIndexVertexArray.java | 84 + .../BulletCollision/btTriangleInfo.java | 41 + .../BulletCollision/btTriangleInfoData.java | 41 + .../BulletCollision/btTriangleInfoMap.java | 48 + .../btTriangleInfoMapData.java | 51 + .../BulletCollision/btTriangleMesh.java | 62 + .../BulletCollision/btTriangleMeshShape.java | 46 + .../btTriangleMeshShapeData.java | 51 + .../btUniformScalingShape.java | 58 + .../btVoronoiSimplexSolver.java | 21 + .../org/bytedeco/bullet/BulletDynamics.java | 3860 ----------- .../InplaceSolverIslandCallback.java | 24 + .../BulletDynamics/btActionInterface.java | 23 + ...AlignedObjectArray_btRigidBodyPointer.java | 94 + .../BulletDynamics/btConeTwistConstraint.java | 130 + .../btConeTwistConstraintData.java | 54 + .../btConeTwistConstraintDoubleData.java | 49 + .../BulletDynamics/btConstraintSetting.java | 39 + .../BulletDynamics/btConstraintSolver.java | 37 + .../BulletDynamics/btContactSolverInfo.java | 35 + .../btContactSolverInfoData.java | 70 + .../btContactSolverInfoDoubleData.java | 62 + .../btContactSolverInfoFloatData.java | 64 + .../btDefaultVehicleRaycaster.java | 28 + .../btDiscreteDynamicsWorld.java | 121 + .../BulletDynamics/btDynamicsWorld.java | 87 + .../btDynamicsWorldDoubleData.java | 39 + .../btDynamicsWorldFloatData.java | 39 + .../BulletDynamics/btFixedConstraint.java | 26 + .../BulletDynamics/btGearConstraint.java | 54 + .../btGearConstraintDoubleData.java | 42 + .../btGearConstraintFloatData.java | 45 + .../btGeneric6DofConstraint.java | 185 + .../btGeneric6DofConstraintData.java | 48 + .../btGeneric6DofConstraintDoubleData2.java | 48 + .../btGeneric6DofSpring2Constraint.java | 129 + .../btGeneric6DofSpring2ConstraintData.java | 91 + ...neric6DofSpring2ConstraintDoubleData2.java | 91 + .../btGeneric6DofSpringConstraint.java | 60 + .../btGeneric6DofSpringConstraintData.java | 46 + ...eneric6DofSpringConstraintDoubleData2.java | 46 + .../BulletDynamics/btHinge2Constraint.java | 45 + .../btHingeAccumulatedAngleConstraint.java | 48 + .../BulletDynamics/btHingeConstraint.java | 130 + .../btHingeConstraintDoubleData.java | 53 + .../btHingeConstraintDoubleData2.java | 53 + .../btHingeConstraintFloatData.java | 51 + .../btInternalTickCallback.java | 27 + .../BulletDynamics/btPersistentManifold.java | 23 + .../btPoint2PointConstraint.java | 63 + .../btPoint2PointConstraintDoubleData.java | 43 + .../btPoint2PointConstraintDoubleData2.java | 40 + .../btPoint2PointConstraintFloatData.java | 40 + .../BulletDynamics/btRaycastVehicle.java | 123 + .../bullet/BulletDynamics/btRigidBody.java | 253 + .../BulletDynamics/btRigidBodyDoubleData.java | 60 + .../BulletDynamics/btRigidBodyFloatData.java | 59 + .../btRotationalLimitMotor.java | 91 + .../btRotationalLimitMotor2.java | 69 + .../btSequentialImpulseConstraintSolver.java | 59 + .../BulletDynamics/btSimpleDynamicsWorld.java | 64 + .../btSimulationIslandManager.java | 23 + .../BulletDynamics/btSliderConstraint.java | 133 + .../btSliderConstraintData.java | 50 + .../btSliderConstraintDoubleData.java | 48 + .../BulletDynamics/btSolverAnalyticsData.java | 41 + .../bullet/BulletDynamics/btStackAlloc.java | 23 + .../btTranslationalLimitMotor.java | 89 + .../btTranslationalLimitMotor2.java | 75 + .../BulletDynamics/btTypedConstraint.java | 23 + .../BulletDynamics/btUniversalConstraint.java | 49 + .../BulletDynamics/btVehicleRaycaster.java | 47 + .../bullet/BulletDynamics/btWheelInfo.java | 104 + .../btWheelInfoConstructionInfo.java | 49 + .../java/org/bytedeco/bullet/LinearMath.java | 2675 -------- .../bullet/LinearMath/CProfileSample.java | 30 + .../btAlignedObjectArray_btScalar.java | 86 + .../btAlignedObjectArray_btVector3.java | 90 + .../bytedeco/bullet/LinearMath/btChunk.java | 37 + .../bytedeco/bullet/LinearMath/btClock.java | 55 + .../LinearMath/btDefaultMotionState.java | 46 + .../LinearMath/btDefaultSerializer.java | 82 + .../LinearMath/btEnterProfileZoneFunc.java | 24 + .../bytedeco/bullet/LinearMath/btHashInt.java | 33 + .../btHashMap_btHashPtr_voidPointer.java | 51 + .../bytedeco/bullet/LinearMath/btHashPtr.java | 27 + .../bullet/LinearMath/btHashString.java | 43 + .../bullet/LinearMath/btIDebugDraw.java | 124 + .../bullet/LinearMath/btInfMaskConverter.java | 37 + .../LinearMath/btLeaveProfileZoneFunc.java | 21 + .../bullet/LinearMath/btMatrix3x3.java | 247 + .../LinearMath/btMatrix3x3DoubleData.java | 35 + .../LinearMath/btMatrix3x3FloatData.java | 35 + .../bullet/LinearMath/btMotionState.java | 27 + .../bullet/LinearMath/btPointerUid.java | 35 + .../bullet/LinearMath/btQuadWord.java | 120 + .../bullet/LinearMath/btQuaternion.java | 192 + .../LinearMath/btQuaternionDoubleData.java | 34 + .../LinearMath/btQuaternionFloatData.java | 34 + .../bullet/LinearMath/btSerializer.java | 53 + .../bullet/LinearMath/btTransform.java | 147 + .../LinearMath/btTransformDoubleData.java | 34 + .../LinearMath/btTransformFloatData.java | 35 + .../bullet/LinearMath/btTypedObject.java | 25 + .../bytedeco/bullet/LinearMath/btVector3.java | 238 + .../LinearMath/btVector3DoubleData.java | 34 + .../bullet/LinearMath/btVector3FloatData.java | 34 + .../bytedeco/bullet/LinearMath/btVector4.java | 68 + .../bullet/global/BulletCollision.java | 1884 ++++++ .../bullet/global/BulletDynamics.java | 1070 ++++ .../bytedeco/bullet/global/LinearMath.java | 992 +++ .../bullet/presets/BulletCollision.java | 3 +- .../bullet/presets/BulletDynamics.java | 3 +- .../bytedeco/bullet/presets/LinearMath.java | 3 +- bullet/src/main/java9/module-info.java | 1 + 226 files changed, 16114 insertions(+), 12153 deletions(-) delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/CalculateCombinedCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactAddedCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btActivatingCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseAabbCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePair.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePairSortPredicate.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseRayCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCharIndexTripletData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcher.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObject.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChildData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConcaveShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConstraintRow.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalAabbCachingShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleMeshShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConfiguration.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConstructionInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDiscreteCollisionDetectorInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcher.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIntIndexData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btInternalTriangleIndexCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldPoint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldResult.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMeshPartData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNearCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapFilterCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexAabbCachingShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoolAllocator.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPositionAndRadius.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btRigidBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledBvhTriangleMeshShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledTriangleMeshShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexTripletData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphaseProxy.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStorageResult.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterfaceData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMesh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUniformScalingShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDefaultVehicleRaycaster.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btInternalTickCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPersistentManifold.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManager.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btStackAlloc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btUniversalConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoConstructionInfo.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultMotionState.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultSerializer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashString.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btInfMaskConverter.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransform.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3DoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision.java deleted file mode 100644 index 2fef9bfa1d9..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision.java +++ /dev/null @@ -1,5615 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import static org.bytedeco.bullet.LinearMath.*; - -public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision { - static { Loader.load(); } - -// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseProxy.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_BROADPHASE_PROXY_H -// #define BT_BROADPHASE_PROXY_H - -// #include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btAlignedAllocator.h" - -/** btDispatcher uses these types - * IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave - * to facilitate type checking - * CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code */ -/** enum BroadphaseNativeTypes */ -public static final int - // polyhedral convex shapes - BOX_SHAPE_PROXYTYPE = 0, - TRIANGLE_SHAPE_PROXYTYPE = 1, - TETRAHEDRAL_SHAPE_PROXYTYPE = 2, - CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE = 3, - CONVEX_HULL_SHAPE_PROXYTYPE = 4, - CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE = 5, - CUSTOM_POLYHEDRAL_SHAPE_TYPE = 6, - //implicit convex shapes - IMPLICIT_CONVEX_SHAPES_START_HERE = 7, - SPHERE_SHAPE_PROXYTYPE = 8, - MULTI_SPHERE_SHAPE_PROXYTYPE = 9, - CAPSULE_SHAPE_PROXYTYPE = 10, - CONE_SHAPE_PROXYTYPE = 11, - CONVEX_SHAPE_PROXYTYPE = 12, - CYLINDER_SHAPE_PROXYTYPE = 13, - UNIFORM_SCALING_SHAPE_PROXYTYPE = 14, - MINKOWSKI_SUM_SHAPE_PROXYTYPE = 15, - MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE = 16, - BOX_2D_SHAPE_PROXYTYPE = 17, - CONVEX_2D_SHAPE_PROXYTYPE = 18, - CUSTOM_CONVEX_SHAPE_TYPE = 19, - //concave shapes - CONCAVE_SHAPES_START_HERE = 20, - //keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy! - TRIANGLE_MESH_SHAPE_PROXYTYPE = 21, - SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE = 22, - /**used for demo integration FAST/Swift collision library and Bullet */ - FAST_CONCAVE_MESH_PROXYTYPE = 23, - //terrain - TERRAIN_SHAPE_PROXYTYPE = 24, - /**Used for GIMPACT Trimesh integration */ - GIMPACT_SHAPE_PROXYTYPE = 25, - /**Multimaterial mesh */ - MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE = 26, - - EMPTY_SHAPE_PROXYTYPE = 27, - STATIC_PLANE_PROXYTYPE = 28, - CUSTOM_CONCAVE_SHAPE_TYPE = 29, - SDF_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE, - CONCAVE_SHAPES_END_HERE = CUSTOM_CONCAVE_SHAPE_TYPE + 1, - - COMPOUND_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 2, - - SOFTBODY_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 3, - HFFLUID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 4, - HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 5, - INVALID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 6, - - MAX_BROADPHASE_COLLISION_TYPES = CUSTOM_CONCAVE_SHAPE_TYPE + 7; - -/**The btBroadphaseProxy is the main class that can be used with the Bullet broadphases. - * It stores collision shape type information, collision filter information and a client object, typically a btCollisionObject or btRigidBody. */ -@NoOffset public static class btBroadphaseProxy extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBroadphaseProxy(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btBroadphaseProxy(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btBroadphaseProxy position(long position) { - return (btBroadphaseProxy)super.position(position); - } - @Override public btBroadphaseProxy getPointer(long i) { - return new btBroadphaseProxy((Pointer)this).offsetAddress(i); - } - - - /**optional filtering to cull potential collisions */ - /** enum btBroadphaseProxy::CollisionFilterGroups */ - public static final int - DefaultFilter = 1, - StaticFilter = 2, - KinematicFilter = 4, - DebrisFilter = 8, - SensorTrigger = 16, - CharacterFilter = 32, - AllFilter = -1; //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger - - //Usually the client btCollisionObject or Rigidbody class - public native Pointer m_clientObject(); public native btBroadphaseProxy m_clientObject(Pointer setter); - public native int m_collisionFilterGroup(); public native btBroadphaseProxy m_collisionFilterGroup(int setter); - public native int m_collisionFilterMask(); public native btBroadphaseProxy m_collisionFilterMask(int setter); - - public native int m_uniqueId(); public native btBroadphaseProxy m_uniqueId(int setter); //m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. - - public native @ByRef btVector3 m_aabbMin(); public native btBroadphaseProxy m_aabbMin(btVector3 setter); - public native @ByRef btVector3 m_aabbMax(); public native btBroadphaseProxy m_aabbMax(btVector3 setter); - - public native int getUid(); - - //used for memory pools - public btBroadphaseProxy() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btBroadphaseProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask); } - private native void allocate(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); - - public static native @Cast("bool") boolean isPolyhedral(int proxyType); - - public static native @Cast("bool") boolean isConvex(int proxyType); - - public static native @Cast("bool") boolean isNonMoving(int proxyType); - - public static native @Cast("bool") boolean isConcave(int proxyType); - public static native @Cast("bool") boolean isCompound(int proxyType); - - public static native @Cast("bool") boolean isSoftBody(int proxyType); - - public static native @Cast("bool") boolean isInfinite(int proxyType); - - public static native @Cast("bool") boolean isConvex2d(int proxyType); -} - -@Opaque public static class btCollisionAlgorithm extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionAlgorithm() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionAlgorithm(Pointer p) { super(p); } -} - -/**The btBroadphasePair class contains a pair of aabb-overlapping objects. - * A btDispatcher can search a btCollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes. */ -@NoOffset public static class btBroadphasePair extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBroadphasePair(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btBroadphasePair(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btBroadphasePair position(long position) { - return (btBroadphasePair)super.position(position); - } - @Override public btBroadphasePair getPointer(long i) { - return new btBroadphasePair((Pointer)this).offsetAddress(i); - } - - public btBroadphasePair() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btBroadphasePair(@ByRef btBroadphaseProxy proxy0, @ByRef btBroadphaseProxy proxy1) { super((Pointer)null); allocate(proxy0, proxy1); } - private native void allocate(@ByRef btBroadphaseProxy proxy0, @ByRef btBroadphaseProxy proxy1); - - public native btBroadphaseProxy m_pProxy0(); public native btBroadphasePair m_pProxy0(btBroadphaseProxy setter); - public native btBroadphaseProxy m_pProxy1(); public native btBroadphasePair m_pProxy1(btBroadphaseProxy setter); - - public native btCollisionAlgorithm m_algorithm(); public native btBroadphasePair m_algorithm(btCollisionAlgorithm setter); - public native Pointer m_internalInfo1(); public native btBroadphasePair m_internalInfo1(Pointer setter); - public native int m_internalTmpValue(); public native btBroadphasePair m_internalTmpValue(int setter); //don't use this data, it will be removed in future version. -} - -/* -//comparison for set operation, see Solid DT_Encounter -SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) -{ - return a.m_pProxy0 < b.m_pProxy0 || - (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); -} -*/ - -public static class btBroadphasePairSortPredicate extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btBroadphasePairSortPredicate() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btBroadphasePairSortPredicate(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBroadphasePairSortPredicate(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btBroadphasePairSortPredicate position(long position) { - return (btBroadphasePairSortPredicate)super.position(position); - } - @Override public btBroadphasePairSortPredicate getPointer(long i) { - return new btBroadphasePairSortPredicate((Pointer)this).offsetAddress(i); - } - - public native @Cast("bool") @Name("operator ()") boolean apply(@Const @ByRef btBroadphasePair a, @Const @ByRef btBroadphasePair b); -} - -public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btBroadphasePair a, @Const @ByRef btBroadphasePair b); - -// #endif //BT_BROADPHASE_PROXY_H - - -// Parsed from BulletCollision/BroadphaseCollision/btDispatcher.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_DISPATCHER_H -// #define BT_DISPATCHER_H -// #include "LinearMath/btScalar.h" -@Opaque public static class btRigidBody extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btRigidBody() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRigidBody(Pointer p) { super(p); } -} -@Opaque public static class btCollisionObjectWrapper extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionObjectWrapper() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionObjectWrapper(Pointer p) { super(p); } -} - -@Opaque public static class btPersistentManifold extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btPersistentManifold() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPersistentManifold(Pointer p) { super(p); } -} -@Opaque public static class btPoolAllocator extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btPoolAllocator() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPoolAllocator(Pointer p) { super(p); } -} - -@NoOffset public static class btDispatcherInfo extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDispatcherInfo(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btDispatcherInfo(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btDispatcherInfo position(long position) { - return (btDispatcherInfo)super.position(position); - } - @Override public btDispatcherInfo getPointer(long i) { - return new btDispatcherInfo((Pointer)this).offsetAddress(i); - } - - /** enum btDispatcherInfo::DispatchFunc */ - public static final int - DISPATCH_DISCRETE = 1, - DISPATCH_CONTINUOUS = 2; - public btDispatcherInfo() { super((Pointer)null); allocate(); } - private native void allocate(); - public native @Cast("btScalar") float m_timeStep(); public native btDispatcherInfo m_timeStep(float setter); - public native int m_stepCount(); public native btDispatcherInfo m_stepCount(int setter); - public native int m_dispatchFunc(); public native btDispatcherInfo m_dispatchFunc(int setter); - public native @Cast("btScalar") float m_timeOfImpact(); public native btDispatcherInfo m_timeOfImpact(float setter); - public native @Cast("bool") boolean m_useContinuous(); public native btDispatcherInfo m_useContinuous(boolean setter); - public native btIDebugDraw m_debugDraw(); public native btDispatcherInfo m_debugDraw(btIDebugDraw setter); - public native @Cast("bool") boolean m_enableSatConvex(); public native btDispatcherInfo m_enableSatConvex(boolean setter); - public native @Cast("bool") boolean m_enableSPU(); public native btDispatcherInfo m_enableSPU(boolean setter); - public native @Cast("bool") boolean m_useEpa(); public native btDispatcherInfo m_useEpa(boolean setter); - public native @Cast("btScalar") float m_allowedCcdPenetration(); public native btDispatcherInfo m_allowedCcdPenetration(float setter); - public native @Cast("bool") boolean m_useConvexConservativeDistanceUtil(); public native btDispatcherInfo m_useConvexConservativeDistanceUtil(boolean setter); - public native @Cast("btScalar") float m_convexConservativeDistanceThreshold(); public native btDispatcherInfo m_convexConservativeDistanceThreshold(float setter); - public native @Cast("bool") boolean m_deterministicOverlappingPairs(); public native btDispatcherInfo m_deterministicOverlappingPairs(boolean setter); -} - -/** enum ebtDispatcherQueryType */ -public static final int - BT_CONTACT_POINT_ALGORITHMS = 1, - BT_CLOSEST_POINT_ALGORITHMS = 2; - -/**The btDispatcher interface class can be used in combination with broadphase to dispatch calculations for overlapping pairs. - * For example for pairwise collision detection, calculating contact points stored in btPersistentManifold or user callbacks (game logic). */ -public static class btDispatcher extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDispatcher(Pointer p) { super(p); } - - - public native btCollisionAlgorithm findAlgorithm(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold, @Cast("ebtDispatcherQueryType") int queryType); - - public native btPersistentManifold getNewManifold(@Const btCollisionObject b0, @Const btCollisionObject b1); - - public native void releaseManifold(btPersistentManifold manifold); - - public native void clearManifold(btPersistentManifold manifold); - - public native @Cast("bool") boolean needsCollision(@Const btCollisionObject body0, @Const btCollisionObject body1); - - public native @Cast("bool") boolean needsResponse(@Const btCollisionObject body0, @Const btCollisionObject body1); - - public native void dispatchAllCollisionPairs(btOverlappingPairCache pairCache, @Const @ByRef btDispatcherInfo dispatchInfo, btDispatcher dispatcher); - - public native int getNumManifolds(); - - public native btPersistentManifold getManifoldByIndexInternal(int index); - - public native @Cast("btPersistentManifold**") PointerPointer getInternalManifoldPointer(); - - public native btPoolAllocator getInternalManifoldPool(); - - public native Pointer allocateCollisionAlgorithm(int size); - - public native void freeCollisionAlgorithm(Pointer ptr); -} - -// #endif //BT_DISPATCHER_H - - -// Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h - - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef OVERLAPPING_PAIR_CALLBACK_H -// #define OVERLAPPING_PAIR_CALLBACK_H - -/**The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache. */ -public static class btOverlappingPairCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btOverlappingPairCallback(Pointer p) { super(p); } - - - public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); - - public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy0, btDispatcher dispatcher); -} - -// #endif //OVERLAPPING_PAIR_CALLBACK_H - - -// Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCache.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_OVERLAPPING_PAIR_CACHE_H -// #define BT_OVERLAPPING_PAIR_CACHE_H - -// #include "btBroadphaseInterface.h" -// #include "btBroadphaseProxy.h" -// #include "btOverlappingPairCallback.h" - -// #include "LinearMath/btAlignedObjectArray.h" - -public static class btOverlapCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btOverlapCallback(Pointer p) { super(p); } - - //return true for deletion of the pair - public native @Cast("bool") boolean processOverlap(@ByRef btBroadphasePair pair); -} - -public static class btOverlapFilterCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btOverlapFilterCallback(Pointer p) { super(p); } - - // return true when pairs need collision - public native @Cast("bool") boolean needBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); -} - -@MemberGetter public static native int BT_NULL_PAIR(); - -/**The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases. - * The btHashedOverlappingPairCache and btSortedOverlappingPairCache classes are two implementations. */ -public static class btOverlappingPairCache extends btOverlappingPairCallback { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btOverlappingPairCache(Pointer p) { super(p); } - // this is needed so we can get to the derived class destructor - - public native btBroadphasePair getOverlappingPairArrayPtr(); - - - - public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); - - public native int getNumOverlappingPairs(); - public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - public native btOverlapFilterCallback getOverlapFilterCallback(); - public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); - - public native void setOverlapFilterCallback(btOverlapFilterCallback callback); - - public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); - - public native void processAllOverlappingPairs(btOverlapCallback callback, btDispatcher dispatcher, @Const @ByRef btDispatcherInfo arg2); - public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - public native @Cast("bool") boolean hasDeferredRemoval(); - - public native void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback); - - public native void sortOverlappingPairs(btDispatcher dispatcher); -} - -/** Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com */ - -@NoOffset public static class btHashedOverlappingPairCache extends btOverlappingPairCache { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHashedOverlappingPairCache(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btHashedOverlappingPairCache(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btHashedOverlappingPairCache position(long position) { - return (btHashedOverlappingPairCache)super.position(position); - } - @Override public btHashedOverlappingPairCache getPointer(long i) { - return new btHashedOverlappingPairCache((Pointer)this).offsetAddress(i); - } - - - public btHashedOverlappingPairCache() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); - - public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); - - public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - // Add a pair and return the new pair. If the pair already exists, - // no new pair is created and the old one is returned. - public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); - - public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); - - public native void processAllOverlappingPairs(btOverlapCallback callback, btDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); - - public native btBroadphasePair getOverlappingPairArrayPtr(); - - - - - - public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); - - public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - public native int GetCount(); - // btBroadphasePair* GetPairs() { return m_pairs; } - - public native btOverlapFilterCallback getOverlapFilterCallback(); - - public native void setOverlapFilterCallback(btOverlapFilterCallback callback); - - public native int getNumOverlappingPairs(); -} - -/**btSortedOverlappingPairCache maintains the objects with overlapping AABB - * Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase */ -@NoOffset public static class btSortedOverlappingPairCache extends btOverlappingPairCache { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSortedOverlappingPairCache(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btSortedOverlappingPairCache(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btSortedOverlappingPairCache position(long position) { - return (btSortedOverlappingPairCache)super.position(position); - } - @Override public btSortedOverlappingPairCache getPointer(long i) { - return new btSortedOverlappingPairCache((Pointer)this).offsetAddress(i); - } - - public btSortedOverlappingPairCache() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); - - public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); - - public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); - - public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); - - public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); - - public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - - - - - public native btBroadphasePair getOverlappingPairArrayPtr(); - - public native int getNumOverlappingPairs(); - - public native btOverlapFilterCallback getOverlapFilterCallback(); - - public native void setOverlapFilterCallback(btOverlapFilterCallback callback); - - public native @Cast("bool") boolean hasDeferredRemoval(); - - public native void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback); - - public native void sortOverlappingPairs(btDispatcher dispatcher); -} - -/**btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing. */ -@NoOffset public static class btNullPairCache extends btOverlappingPairCache { - static { Loader.load(); } - /** Default native constructor. */ - public btNullPairCache() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btNullPairCache(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btNullPairCache(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btNullPairCache position(long position) { - return (btNullPairCache)super.position(position); - } - @Override public btNullPairCache getPointer(long i) { - return new btNullPairCache((Pointer)this).offsetAddress(i); - } - - public native btBroadphasePair getOverlappingPairArrayPtr(); - - - public native void cleanOverlappingPair(@ByRef btBroadphasePair arg0, btDispatcher arg1); - - public native int getNumOverlappingPairs(); - - public native void cleanProxyFromPairs(btBroadphaseProxy arg0, btDispatcher arg1); - - public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy arg0, btBroadphaseProxy arg1); - public native btOverlapFilterCallback getOverlapFilterCallback(); - public native void setOverlapFilterCallback(btOverlapFilterCallback arg0); - - public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher arg1); - - public native btBroadphasePair findPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1); - - public native @Cast("bool") boolean hasDeferredRemoval(); - - public native void setInternalGhostPairCallback(btOverlappingPairCallback arg0); - - public native btBroadphasePair addOverlappingPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1); - - public native Pointer removeOverlappingPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1, btDispatcher arg2); - - public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy arg0, btDispatcher arg1); - - public native void sortOverlappingPairs(btDispatcher dispatcher); -} - -// #endif //BT_OVERLAPPING_PAIR_CACHE_H - - -// Parsed from BulletCollision/BroadphaseCollision/btQuantizedBvh.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_QUANTIZED_BVH_H -// #define BT_QUANTIZED_BVH_H - -//#define DEBUG_CHECK_DEQUANTIZATION 1 -// #ifdef DEBUG_CHECK_DEQUANTIZATION -// #ifdef __SPU__ -// #endif //__SPU__ - -// #include -// #include -// #endif //DEBUG_CHECK_DEQUANTIZATION - -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btAlignedAllocator.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btQuantizedBvhData btQuantizedBvhFloatData -// #define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData -public static final String btQuantizedBvhDataName = "btQuantizedBvhFloatData"; -// #endif - -//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp - -//Note: currently we have 16 bytes per quantized node -public static final int MAX_SUBTREE_SIZE_IN_BYTES = 2048; - -// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one -// actually) triangles each (since the sign bit is reserved -public static final int MAX_NUM_PARTS_IN_BITS = 10; - -/**btQuantizedBvhNode is a compressed aabb node, 16 bytes. - * Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range). */ -public static class btQuantizedBvhNode extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btQuantizedBvhNode() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuantizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuantizedBvhNode(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btQuantizedBvhNode position(long position) { - return (btQuantizedBvhNode)super.position(position); - } - @Override public btQuantizedBvhNode getPointer(long i) { - return new btQuantizedBvhNode((Pointer)this).offsetAddress(i); - } - - - //12 bytes - public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native btQuantizedBvhNode m_quantizedAabbMin(int i, short setter); - @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); - public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native btQuantizedBvhNode m_quantizedAabbMax(int i, short setter); - @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); - //4 bytes - public native int m_escapeIndexOrTriangleIndex(); public native btQuantizedBvhNode m_escapeIndexOrTriangleIndex(int setter); - - public native @Cast("bool") boolean isLeafNode(); - public native int getEscapeIndex(); - public native int getTriangleIndex(); - public native int getPartId(); -} - -/** btOptimizedBvhNode contains both internal and leaf node information. - * Total node size is 44 bytes / node. You can use the compressed version of 16 bytes. */ -public static class btOptimizedBvhNode extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btOptimizedBvhNode() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btOptimizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btOptimizedBvhNode(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btOptimizedBvhNode position(long position) { - return (btOptimizedBvhNode)super.position(position); - } - @Override public btOptimizedBvhNode getPointer(long i) { - return new btOptimizedBvhNode((Pointer)this).offsetAddress(i); - } - - - //32 bytes - public native @ByRef btVector3 m_aabbMinOrg(); public native btOptimizedBvhNode m_aabbMinOrg(btVector3 setter); - public native @ByRef btVector3 m_aabbMaxOrg(); public native btOptimizedBvhNode m_aabbMaxOrg(btVector3 setter); - - //4 - public native int m_escapeIndex(); public native btOptimizedBvhNode m_escapeIndex(int setter); - - //8 - //for child nodes - public native int m_subPart(); public native btOptimizedBvhNode m_subPart(int setter); - public native int m_triangleIndex(); public native btOptimizedBvhNode m_triangleIndex(int setter); - - //pad the size to 64 bytes - public native @Cast("char") byte m_padding(int i); public native btOptimizedBvhNode m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - -/**btBvhSubtreeInfo provides info to gather a subtree of limited size */ -@NoOffset public static class btBvhSubtreeInfo extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBvhSubtreeInfo(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btBvhSubtreeInfo(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btBvhSubtreeInfo position(long position) { - return (btBvhSubtreeInfo)super.position(position); - } - @Override public btBvhSubtreeInfo getPointer(long i) { - return new btBvhSubtreeInfo((Pointer)this).offsetAddress(i); - } - - - //12 bytes - public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native btBvhSubtreeInfo m_quantizedAabbMin(int i, short setter); - @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); - public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native btBvhSubtreeInfo m_quantizedAabbMax(int i, short setter); - @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); - //4 bytes, points to the root of the subtree - public native int m_rootNodeIndex(); public native btBvhSubtreeInfo m_rootNodeIndex(int setter); - //4 bytes - public native int m_subtreeSize(); public native btBvhSubtreeInfo m_subtreeSize(int setter); - public native int m_padding(int i); public native btBvhSubtreeInfo m_padding(int i, int setter); - @MemberGetter public native IntPointer m_padding(); - - public btBvhSubtreeInfo() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native void setAabbFromQuantizeNode(@Const @ByRef btQuantizedBvhNode quantizedNode); -} - -public static class btNodeOverlapCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btNodeOverlapCallback(Pointer p) { super(p); } - - - public native void processNode(int subPart, int triangleIndex); -} - -// #include "LinearMath/btAlignedAllocator.h" -// #include "LinearMath/btAlignedObjectArray.h" - -/**for code readability: */ - -/**The btQuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU. - * It is used by the btBvhTriangleMeshShape as midphase. - * It is recommended to use quantization for better performance and lower memory requirements. */ -@NoOffset public static class btQuantizedBvh extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuantizedBvh(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuantizedBvh(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btQuantizedBvh position(long position) { - return (btQuantizedBvh)super.position(position); - } - @Override public btQuantizedBvh getPointer(long i) { - return new btQuantizedBvh((Pointer)this).offsetAddress(i); - } - - /** enum btQuantizedBvh::btTraversalMode */ - public static final int - TRAVERSAL_STACKLESS = 0, - TRAVERSAL_STACKLESS_CACHE_FRIENDLY = 1, - TRAVERSAL_RECURSIVE = 2; - - public btQuantizedBvh() { super((Pointer)null); allocate(); } - private native void allocate(); - - ///***************************************** expert/internal use only ************************* - public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("btScalar") float quantizationMargin/*=btScalar(1.0)*/); - public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); - public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btVector3 getLeafNodeArray(); - /**buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized */ - public native void buildInternal(); - ///***************************************** expert/internal use only ************************* - - public native void reportAabbOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - public native void reportRayOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget); - public native void reportBoxCastOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - public native void quantize(@Cast("unsigned short*") ShortPointer out, @Const @ByRef btVector3 point, int isMax); - public native void quantize(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef btVector3 point, int isMax); - public native void quantize(@Cast("unsigned short*") short[] out, @Const @ByRef btVector3 point, int isMax); - - public native void quantizeWithClamp(@Cast("unsigned short*") ShortPointer out, @Const @ByRef btVector3 point2, int isMax); - public native void quantizeWithClamp(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef btVector3 point2, int isMax); - public native void quantizeWithClamp(@Cast("unsigned short*") short[] out, @Const @ByRef btVector3 point2, int isMax); - - public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") ShortPointer vecIn); - public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") ShortBuffer vecIn); - public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") short[] vecIn); - - /**setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees. */ - public native void setTraversalMode(@Cast("btQuantizedBvh::btTraversalMode") int traversalMode); - - public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btVector3 getQuantizedNodeArray(); - - public native @Cast("BvhSubtreeInfoArray*") @ByRef btAlignedObjectArray_btVector3 getSubtreeInfoArray(); - - //////////////////////////////////////////////////////////////////// - - /////Calculate space needed to store BVH for serialization - public native @Cast("unsigned") int calculateSerializeBufferSize(); - - /** Data buffer MUST be 16 byte aligned */ - public native @Cast("bool") boolean serialize(Pointer o_alignedDataBuffer, @Cast("unsigned") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); - - /**deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' */ - public static native btQuantizedBvh deSerializeInPlace(Pointer i_alignedDataBuffer, @Cast("unsigned int") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); - - public static native @Cast("unsigned int") int getAlignmentSerializationPadding(); - ////////////////////////////////////////////////////////////////////// - - public native int calculateSerializeBufferSizeNew(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); - - public native void deSerializeFloat(@ByRef btQuantizedBvhFloatData quantizedBvhFloatData); - - public native void deSerializeDouble(@ByRef btQuantizedBvhDoubleData quantizedBvhDoubleData); - - //////////////////////////////////////////////////////////////////// - - public native @Cast("bool") boolean isQuantized(); -} - -// clang-format off -// parser needs * with the name -public static class btBvhSubtreeInfoData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btBvhSubtreeInfoData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btBvhSubtreeInfoData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBvhSubtreeInfoData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btBvhSubtreeInfoData position(long position) { - return (btBvhSubtreeInfoData)super.position(position); - } - @Override public btBvhSubtreeInfoData getPointer(long i) { - return new btBvhSubtreeInfoData((Pointer)this).offsetAddress(i); - } - - public native int m_rootNodeIndex(); public native btBvhSubtreeInfoData m_rootNodeIndex(int setter); - public native int m_subtreeSize(); public native btBvhSubtreeInfoData m_subtreeSize(int setter); - public native @Cast("unsigned short") short m_quantizedAabbMin(int i); public native btBvhSubtreeInfoData m_quantizedAabbMin(int i, short setter); - @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMin(); - public native @Cast("unsigned short") short m_quantizedAabbMax(int i); public native btBvhSubtreeInfoData m_quantizedAabbMax(int i, short setter); - @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMax(); -} - -public static class btOptimizedBvhNodeFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btOptimizedBvhNodeFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btOptimizedBvhNodeFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btOptimizedBvhNodeFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btOptimizedBvhNodeFloatData position(long position) { - return (btOptimizedBvhNodeFloatData)super.position(position); - } - @Override public btOptimizedBvhNodeFloatData getPointer(long i) { - return new btOptimizedBvhNodeFloatData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3FloatData m_aabbMinOrg(); public native btOptimizedBvhNodeFloatData m_aabbMinOrg(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_aabbMaxOrg(); public native btOptimizedBvhNodeFloatData m_aabbMaxOrg(btVector3FloatData setter); - public native int m_escapeIndex(); public native btOptimizedBvhNodeFloatData m_escapeIndex(int setter); - public native int m_subPart(); public native btOptimizedBvhNodeFloatData m_subPart(int setter); - public native int m_triangleIndex(); public native btOptimizedBvhNodeFloatData m_triangleIndex(int setter); - public native @Cast("char") byte m_pad(int i); public native btOptimizedBvhNodeFloatData m_pad(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_pad(); -} - -public static class btOptimizedBvhNodeDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btOptimizedBvhNodeDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btOptimizedBvhNodeDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btOptimizedBvhNodeDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btOptimizedBvhNodeDoubleData position(long position) { - return (btOptimizedBvhNodeDoubleData)super.position(position); - } - @Override public btOptimizedBvhNodeDoubleData getPointer(long i) { - return new btOptimizedBvhNodeDoubleData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3DoubleData m_aabbMinOrg(); public native btOptimizedBvhNodeDoubleData m_aabbMinOrg(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_aabbMaxOrg(); public native btOptimizedBvhNodeDoubleData m_aabbMaxOrg(btVector3DoubleData setter); - public native int m_escapeIndex(); public native btOptimizedBvhNodeDoubleData m_escapeIndex(int setter); - public native int m_subPart(); public native btOptimizedBvhNodeDoubleData m_subPart(int setter); - public native int m_triangleIndex(); public native btOptimizedBvhNodeDoubleData m_triangleIndex(int setter); - public native @Cast("char") byte m_pad(int i); public native btOptimizedBvhNodeDoubleData m_pad(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_pad(); -} - - -public static class btQuantizedBvhNodeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btQuantizedBvhNodeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuantizedBvhNodeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuantizedBvhNodeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btQuantizedBvhNodeData position(long position) { - return (btQuantizedBvhNodeData)super.position(position); - } - @Override public btQuantizedBvhNodeData getPointer(long i) { - return new btQuantizedBvhNodeData((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned short") short m_quantizedAabbMin(int i); public native btQuantizedBvhNodeData m_quantizedAabbMin(int i, short setter); - @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMin(); - public native @Cast("unsigned short") short m_quantizedAabbMax(int i); public native btQuantizedBvhNodeData m_quantizedAabbMax(int i, short setter); - @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMax(); - public native int m_escapeIndexOrTriangleIndex(); public native btQuantizedBvhNodeData m_escapeIndexOrTriangleIndex(int setter); -} - -public static class btQuantizedBvhFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btQuantizedBvhFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuantizedBvhFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuantizedBvhFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btQuantizedBvhFloatData position(long position) { - return (btQuantizedBvhFloatData)super.position(position); - } - @Override public btQuantizedBvhFloatData getPointer(long i) { - return new btQuantizedBvhFloatData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3FloatData m_bvhAabbMin(); public native btQuantizedBvhFloatData m_bvhAabbMin(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_bvhAabbMax(); public native btQuantizedBvhFloatData m_bvhAabbMax(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_bvhQuantization(); public native btQuantizedBvhFloatData m_bvhQuantization(btVector3FloatData setter); - public native int m_curNodeIndex(); public native btQuantizedBvhFloatData m_curNodeIndex(int setter); - public native int m_useQuantization(); public native btQuantizedBvhFloatData m_useQuantization(int setter); - public native int m_numContiguousLeafNodes(); public native btQuantizedBvhFloatData m_numContiguousLeafNodes(int setter); - public native int m_numQuantizedContiguousNodes(); public native btQuantizedBvhFloatData m_numQuantizedContiguousNodes(int setter); - public native btOptimizedBvhNodeFloatData m_contiguousNodesPtr(); public native btQuantizedBvhFloatData m_contiguousNodesPtr(btOptimizedBvhNodeFloatData setter); - public native btQuantizedBvhNodeData m_quantizedContiguousNodesPtr(); public native btQuantizedBvhFloatData m_quantizedContiguousNodesPtr(btQuantizedBvhNodeData setter); - public native btBvhSubtreeInfoData m_subTreeInfoPtr(); public native btQuantizedBvhFloatData m_subTreeInfoPtr(btBvhSubtreeInfoData setter); - public native int m_traversalMode(); public native btQuantizedBvhFloatData m_traversalMode(int setter); - public native int m_numSubtreeHeaders(); public native btQuantizedBvhFloatData m_numSubtreeHeaders(int setter); - -} - -public static class btQuantizedBvhDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btQuantizedBvhDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuantizedBvhDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuantizedBvhDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btQuantizedBvhDoubleData position(long position) { - return (btQuantizedBvhDoubleData)super.position(position); - } - @Override public btQuantizedBvhDoubleData getPointer(long i) { - return new btQuantizedBvhDoubleData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3DoubleData m_bvhAabbMin(); public native btQuantizedBvhDoubleData m_bvhAabbMin(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_bvhAabbMax(); public native btQuantizedBvhDoubleData m_bvhAabbMax(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_bvhQuantization(); public native btQuantizedBvhDoubleData m_bvhQuantization(btVector3DoubleData setter); - public native int m_curNodeIndex(); public native btQuantizedBvhDoubleData m_curNodeIndex(int setter); - public native int m_useQuantization(); public native btQuantizedBvhDoubleData m_useQuantization(int setter); - public native int m_numContiguousLeafNodes(); public native btQuantizedBvhDoubleData m_numContiguousLeafNodes(int setter); - public native int m_numQuantizedContiguousNodes(); public native btQuantizedBvhDoubleData m_numQuantizedContiguousNodes(int setter); - public native btOptimizedBvhNodeDoubleData m_contiguousNodesPtr(); public native btQuantizedBvhDoubleData m_contiguousNodesPtr(btOptimizedBvhNodeDoubleData setter); - public native btQuantizedBvhNodeData m_quantizedContiguousNodesPtr(); public native btQuantizedBvhDoubleData m_quantizedContiguousNodesPtr(btQuantizedBvhNodeData setter); - - public native int m_traversalMode(); public native btQuantizedBvhDoubleData m_traversalMode(int setter); - public native int m_numSubtreeHeaders(); public native btQuantizedBvhDoubleData m_numSubtreeHeaders(int setter); - public native btBvhSubtreeInfoData m_subTreeInfoPtr(); public native btQuantizedBvhDoubleData m_subTreeInfoPtr(btBvhSubtreeInfoData setter); -} -// clang-format on - - - -// #endif //BT_QUANTIZED_BVH_H - - -// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseInterface.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_BROADPHASE_INTERFACE_H -// #define BT_BROADPHASE_INTERFACE_H -// #include "btBroadphaseProxy.h" - -public static class btBroadphaseAabbCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBroadphaseAabbCallback(Pointer p) { super(p); } - - public native @Cast("bool") boolean process(@Const btBroadphaseProxy proxy); -} - -@NoOffset public static class btBroadphaseRayCallback extends btBroadphaseAabbCallback { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBroadphaseRayCallback(Pointer p) { super(p); } - - /**added some cached data to accelerate ray-AABB tests */ - public native @ByRef btVector3 m_rayDirectionInverse(); public native btBroadphaseRayCallback m_rayDirectionInverse(btVector3 setter); - public native @Cast("unsigned int") int m_signs(int i); public native btBroadphaseRayCallback m_signs(int i, int setter); - @MemberGetter public native @Cast("unsigned int*") IntPointer m_signs(); - public native @Cast("btScalar") float m_lambda_max(); public native btBroadphaseRayCallback m_lambda_max(float setter); -} - -// #include "LinearMath/btVector3.h" - -/**The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs. - * Some implementations for this broadphase interface include btAxisSweep3, bt32BitAxisSweep3 and btDbvtBroadphase. - * The actual overlapping pair management, storage, adding and removing of pairs is dealt by the btOverlappingPairCache class. */ -public static class btBroadphaseInterface extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBroadphaseInterface(Pointer p) { super(p); } - - - public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); - public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); - public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); - public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); - public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); - - public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); - - /**calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb */ - public native void calculateOverlappingPairs(btDispatcher dispatcher); - - public native btOverlappingPairCache getOverlappingPairCache(); - - /**getAabb returns the axis aligned bounding box in the 'global' coordinate frame - * will add some transform later */ - public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - /**reset broadphase internal structures, to ensure determinism/reproducability */ - public native void resetPool(btDispatcher dispatcher); - - public native void printStats(); -} - -// #endif //BT_BROADPHASE_INTERFACE_H - - -// Parsed from BulletCollision/BroadphaseCollision/btSimpleBroadphase.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SIMPLE_BROADPHASE_H -// #define BT_SIMPLE_BROADPHASE_H - -// #include "btOverlappingPairCache.h" - -@NoOffset public static class btSimpleBroadphaseProxy extends btBroadphaseProxy { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSimpleBroadphaseProxy(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btSimpleBroadphaseProxy(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btSimpleBroadphaseProxy position(long position) { - return (btSimpleBroadphaseProxy)super.position(position); - } - @Override public btSimpleBroadphaseProxy getPointer(long i) { - return new btSimpleBroadphaseProxy((Pointer)this).offsetAddress(i); - } - - public native int m_nextFree(); public native btSimpleBroadphaseProxy m_nextFree(int setter); - - // int m_handleId; - - public btSimpleBroadphaseProxy() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btSimpleBroadphaseProxy(@Const @ByRef btVector3 minpt, @Const @ByRef btVector3 maxpt, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(minpt, maxpt, shapeType, userPtr, collisionFilterGroup, collisionFilterMask); } - private native void allocate(@Const @ByRef btVector3 minpt, @Const @ByRef btVector3 maxpt, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); - - public native void SetNextFree(int next); - public native int GetNextFree(); -} - -/**The SimpleBroadphase is just a unit-test for btAxisSweep3, bt32BitAxisSweep3, or btDbvtBroadphase, so use those classes instead. - * It is a brute force aabb culling broadphase based on O(n^2) aabb checks */ -@NoOffset public static class btSimpleBroadphase extends btBroadphaseInterface { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSimpleBroadphase(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btSimpleBroadphase(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btSimpleBroadphase position(long position) { - return (btSimpleBroadphase)super.position(position); - } - @Override public btSimpleBroadphase getPointer(long i) { - return new btSimpleBroadphase((Pointer)this).offsetAddress(i); - } - - public btSimpleBroadphase(int maxProxies/*=16384*/, btOverlappingPairCache overlappingPairCache/*=0*/) { super((Pointer)null); allocate(maxProxies, overlappingPairCache); } - private native void allocate(int maxProxies/*=16384*/, btOverlappingPairCache overlappingPairCache/*=0*/); - public btSimpleBroadphase() { super((Pointer)null); allocate(); } - private native void allocate(); - - public static native @Cast("bool") boolean aabbOverlap(btSimpleBroadphaseProxy proxy0, btSimpleBroadphaseProxy proxy1); - - public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); - - public native void calculateOverlappingPairs(btDispatcher dispatcher); - - public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); - public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); - public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); - public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); - public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); - - public native btOverlappingPairCache getOverlappingPairCache(); - - public native @Cast("bool") boolean testAabbOverlap(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - /**getAabb returns the axis aligned bounding box in the 'global' coordinate frame - * will add some transform later */ - public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void printStats(); -} - -// #endif //BT_SIMPLE_BROADPHASE_H - - -// Parsed from BulletCollision/BroadphaseCollision/btAxisSweep3.h - -//Bullet Continuous Collision Detection and Physics Library -//Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -// -// btAxisSweep3.h -// -// Copyright (c) 2006 Simon Hobbs -// -// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. - -// #ifndef BT_AXIS_SWEEP_3_H -// #define BT_AXIS_SWEEP_3_H - -// #include "LinearMath/btVector3.h" -// #include "btOverlappingPairCache.h" -// #include "btBroadphaseInterface.h" -// #include "btBroadphaseProxy.h" -// #include "btOverlappingPairCallback.h" -// #include "btDbvtBroadphase.h" -// #include "btAxisSweep3Internal.h" - -/** The btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase. - * It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit integer coordinates instead of floats. - * For large worlds and many objects, use bt32BitAxisSweep3 or btDbvtBroadphase instead. bt32BitAxisSweep3 has higher precision and allows more then 16384 objects at the cost of more memory and bit of performance. */ -public static class btAxisSweep3 extends btBroadphaseInterface { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAxisSweep3(Pointer p) { super(p); } - - public btAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned short int") short maxHandles/*=16384*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax, maxHandles, pairCache, disableRaycastAccelerator); } - private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned short int") short maxHandles/*=16384*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/); - public btAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax); } - private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax); -} - -/** The bt32BitAxisSweep3 allows higher precision quantization and more objects compared to the btAxisSweep3 sweep and prune. - * This comes at the cost of more memory per handle, and a bit slower performance. - * It uses arrays rather then lists for storage of the 3 axis. */ -public static class bt32BitAxisSweep3 extends btBroadphaseInterface { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public bt32BitAxisSweep3(Pointer p) { super(p); } - - public bt32BitAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned int") int maxHandles/*=1500000*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax, maxHandles, pairCache, disableRaycastAccelerator); } - private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned int") int maxHandles/*=1500000*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/); - public bt32BitAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax); } - private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax); -} - -// #endif - - -// Parsed from BulletCollision/BroadphaseCollision/btDbvtBroadphase.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -/**btDbvtBroadphase implementation by Nathanael Presson */ -// #ifndef BT_DBVT_BROADPHASE_H -// #define BT_DBVT_BROADPHASE_H - -// #include "BulletCollision/BroadphaseCollision/btDbvt.h" -// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" - -// -// Compile time config -// - -public static native @MemberGetter int DBVT_BP_PROFILE(); -public static final int DBVT_BP_PROFILE = DBVT_BP_PROFILE(); -//#define DBVT_BP_SORTPAIRS 1 -public static final int DBVT_BP_PREVENTFALSEUPDATE = 0; -public static final int DBVT_BP_ACCURATESLEEPING = 0; -public static final int DBVT_BP_ENABLE_BENCHMARK = 0; -//#define DBVT_BP_MARGIN (btScalar)0.05 -public static native @Cast("btScalar") float gDbvtMargin(); public static native void gDbvtMargin(float setter); - -// #if DBVT_BP_PROFILE -// #endif - -// -// btDbvtProxy -// - -/**The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt). - * One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other. - * This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases btAxisSweep3 and bt32BitAxisSweep3. */ -@NoOffset public static class btDbvtBroadphase extends btBroadphaseInterface { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDbvtBroadphase(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btDbvtBroadphase(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btDbvtBroadphase position(long position) { - return (btDbvtBroadphase)super.position(position); - } - @Override public btDbvtBroadphase getPointer(long i) { - return new btDbvtBroadphase((Pointer)this).offsetAddress(i); - } - - /* Config */ - /** enum btDbvtBroadphase:: */ - public static final int - DYNAMIC_SET = 0, /* Dynamic set index */ - FIXED_SET = 1, /* Fixed set index */ - STAGECOUNT = 2; /* Number of stages */ - /* Fields */ - public native @ByRef btDbvt m_sets(int i); public native btDbvtBroadphase m_sets(int i, btDbvt setter); - @MemberGetter public native btDbvt m_sets(); // Dbvt sets // Stages list - public native btOverlappingPairCache m_paircache(); public native btDbvtBroadphase m_paircache(btOverlappingPairCache setter); // Pair cache - public native @Cast("btScalar") float m_prediction(); public native btDbvtBroadphase m_prediction(float setter); // Velocity prediction - public native int m_stageCurrent(); public native btDbvtBroadphase m_stageCurrent(int setter); // Current stage - public native int m_fupdates(); public native btDbvtBroadphase m_fupdates(int setter); // % of fixed updates per frame - public native int m_dupdates(); public native btDbvtBroadphase m_dupdates(int setter); // % of dynamic updates per frame - public native int m_cupdates(); public native btDbvtBroadphase m_cupdates(int setter); // % of cleanup updates per frame - public native int m_newpairs(); public native btDbvtBroadphase m_newpairs(int setter); // Number of pairs created - public native int m_fixedleft(); public native btDbvtBroadphase m_fixedleft(int setter); // Fixed optimization left - public native @Cast("unsigned") int m_updates_call(); public native btDbvtBroadphase m_updates_call(int setter); // Number of updates call - public native @Cast("unsigned") int m_updates_done(); public native btDbvtBroadphase m_updates_done(int setter); // Number of updates done - public native @Cast("btScalar") float m_updates_ratio(); public native btDbvtBroadphase m_updates_ratio(float setter); // m_updates_done/m_updates_call - public native int m_pid(); public native btDbvtBroadphase m_pid(int setter); // Parse id - public native int m_cid(); public native btDbvtBroadphase m_cid(int setter); // Cleanup index - public native int m_gid(); public native btDbvtBroadphase m_gid(int setter); // Gen id - public native @Cast("bool") boolean m_releasepaircache(); public native btDbvtBroadphase m_releasepaircache(boolean setter); // Release pair cache on delete - public native @Cast("bool") boolean m_deferedcollide(); public native btDbvtBroadphase m_deferedcollide(boolean setter); // Defere dynamic/static collision to collide call - public native @Cast("bool") boolean m_needcleanup(); public native btDbvtBroadphase m_needcleanup(boolean setter); // Need to run cleanup? - -// #if DBVT_BP_PROFILE -// #endif - /* Methods */ - public btDbvtBroadphase(btOverlappingPairCache paircache/*=0*/) { super((Pointer)null); allocate(paircache); } - private native void allocate(btOverlappingPairCache paircache/*=0*/); - public btDbvtBroadphase() { super((Pointer)null); allocate(); } - private native void allocate(); - public native void collide(btDispatcher dispatcher); - public native void optimize(); - - /* btBroadphaseInterface Implementation */ - public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); - public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); - public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); - public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); - public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); - public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); - - public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - public native void calculateOverlappingPairs(btDispatcher dispatcher); - public native btOverlappingPairCache getOverlappingPairCache(); - public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - public native void printStats(); - - /**reset broadphase internal structures, to ensure determinism/reproducability */ - public native void resetPool(btDispatcher dispatcher); - - public native void performDeferredRemoval(btDispatcher dispatcher); - - public native void setVelocityPrediction(@Cast("btScalar") float prediction); - public native @Cast("btScalar") float getVelocityPrediction(); - - /**this setAabbForceUpdate is similar to setAabb but always forces the aabb update. - * it is not part of the btBroadphaseInterface but specific to btDbvtBroadphase. - * it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see - * http://code.google.com/p/bullet/issues/detail?id=223 */ - public native void setAabbForceUpdate(btBroadphaseProxy absproxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher arg3); - - public static native void benchmark(btBroadphaseInterface arg0); -} - -// #endif - - -// Parsed from BulletCollision/NarrowPhaseCollision/btManifoldPoint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_MANIFOLD_CONTACT_POINT_H -// #define BT_MANIFOLD_CONTACT_POINT_H - -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransformUtil.h" - -// #ifdef PFX_USE_FREE_VECTORMATH -// #else -// Don't change following order of parameters -public static class btConstraintRow extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btConstraintRow() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btConstraintRow(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConstraintRow(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btConstraintRow position(long position) { - return (btConstraintRow)super.position(position); - } - @Override public btConstraintRow getPointer(long i) { - return new btConstraintRow((Pointer)this).offsetAddress(i); - } - - public native @Cast("btScalar") float m_normal(int i); public native btConstraintRow m_normal(int i, float setter); - @MemberGetter public native @Cast("btScalar*") FloatPointer m_normal(); - public native @Cast("btScalar") float m_rhs(); public native btConstraintRow m_rhs(float setter); - public native @Cast("btScalar") float m_jacDiagInv(); public native btConstraintRow m_jacDiagInv(float setter); - public native @Cast("btScalar") float m_lowerLimit(); public native btConstraintRow m_lowerLimit(float setter); - public native @Cast("btScalar") float m_upperLimit(); public native btConstraintRow m_upperLimit(float setter); - public native @Cast("btScalar") float m_accumImpulse(); public native btConstraintRow m_accumImpulse(float setter); -} -// #endif //PFX_USE_FREE_VECTORMATH - -/** enum btContactPointFlags */ -public static final int - BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED = 1, - BT_CONTACT_FLAG_HAS_CONTACT_CFM = 2, - BT_CONTACT_FLAG_HAS_CONTACT_ERP = 4, - BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING = 8, - BT_CONTACT_FLAG_FRICTION_ANCHOR = 16; - -/** ManifoldContactPoint collects and maintains persistent contactpoints. - * used to improve stability and performance of rigidbody dynamics response. */ -@NoOffset public static class btManifoldPoint extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btManifoldPoint(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btManifoldPoint(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btManifoldPoint position(long position) { - return (btManifoldPoint)super.position(position); - } - @Override public btManifoldPoint getPointer(long i) { - return new btManifoldPoint((Pointer)this).offsetAddress(i); - } - - public btManifoldPoint() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btManifoldPoint(@Const @ByRef btVector3 pointA, @Const @ByRef btVector3 pointB, - @Const @ByRef btVector3 normal, - @Cast("btScalar") float distance) { super((Pointer)null); allocate(pointA, pointB, normal, distance); } - private native void allocate(@Const @ByRef btVector3 pointA, @Const @ByRef btVector3 pointB, - @Const @ByRef btVector3 normal, - @Cast("btScalar") float distance); - - public native @ByRef btVector3 m_localPointA(); public native btManifoldPoint m_localPointA(btVector3 setter); - public native @ByRef btVector3 m_localPointB(); public native btManifoldPoint m_localPointB(btVector3 setter); - public native @ByRef btVector3 m_positionWorldOnB(); public native btManifoldPoint m_positionWorldOnB(btVector3 setter); - /**m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity */ - public native @ByRef btVector3 m_positionWorldOnA(); public native btManifoldPoint m_positionWorldOnA(btVector3 setter); - public native @ByRef btVector3 m_normalWorldOnB(); public native btManifoldPoint m_normalWorldOnB(btVector3 setter); - - public native @Cast("btScalar") float m_distance1(); public native btManifoldPoint m_distance1(float setter); - public native @Cast("btScalar") float m_combinedFriction(); public native btManifoldPoint m_combinedFriction(float setter); - public native @Cast("btScalar") float m_combinedRollingFriction(); public native btManifoldPoint m_combinedRollingFriction(float setter); //torsional friction orthogonal to contact normal, useful to make spheres stop rolling forever - public native @Cast("btScalar") float m_combinedSpinningFriction(); public native btManifoldPoint m_combinedSpinningFriction(float setter); //torsional friction around contact normal, useful for grasping objects - public native @Cast("btScalar") float m_combinedRestitution(); public native btManifoldPoint m_combinedRestitution(float setter); - - //BP mod, store contact triangles. - public native int m_partId0(); public native btManifoldPoint m_partId0(int setter); - public native int m_partId1(); public native btManifoldPoint m_partId1(int setter); - public native int m_index0(); public native btManifoldPoint m_index0(int setter); - public native int m_index1(); public native btManifoldPoint m_index1(int setter); - - public native Pointer m_userPersistentData(); public native btManifoldPoint m_userPersistentData(Pointer setter); - //bool m_lateralFrictionInitialized; - public native int m_contactPointFlags(); public native btManifoldPoint m_contactPointFlags(int setter); - - public native @Cast("btScalar") float m_appliedImpulse(); public native btManifoldPoint m_appliedImpulse(float setter); - public native @Cast("btScalar") float m_prevRHS(); public native btManifoldPoint m_prevRHS(float setter); - public native @Cast("btScalar") float m_appliedImpulseLateral1(); public native btManifoldPoint m_appliedImpulseLateral1(float setter); - public native @Cast("btScalar") float m_appliedImpulseLateral2(); public native btManifoldPoint m_appliedImpulseLateral2(float setter); - public native @Cast("btScalar") float m_contactMotion1(); public native btManifoldPoint m_contactMotion1(float setter); - public native @Cast("btScalar") float m_contactMotion2(); public native btManifoldPoint m_contactMotion2(float setter); - public native @Cast("btScalar") float m_contactCFM(); public native btManifoldPoint m_contactCFM(float setter); - public native @Cast("btScalar") float m_combinedContactStiffness1(); public native btManifoldPoint m_combinedContactStiffness1(float setter); - public native @Cast("btScalar") float m_contactERP(); public native btManifoldPoint m_contactERP(float setter); - public native @Cast("btScalar") float m_combinedContactDamping1(); public native btManifoldPoint m_combinedContactDamping1(float setter); - - public native @Cast("btScalar") float m_frictionCFM(); public native btManifoldPoint m_frictionCFM(float setter); - - public native int m_lifeTime(); public native btManifoldPoint m_lifeTime(int setter); //lifetime of the contactpoint in frames - - public native @ByRef btVector3 m_lateralFrictionDir1(); public native btManifoldPoint m_lateralFrictionDir1(btVector3 setter); - public native @ByRef btVector3 m_lateralFrictionDir2(); public native btManifoldPoint m_lateralFrictionDir2(btVector3 setter); - - public native @Cast("btScalar") float getDistance(); - public native int getLifeTime(); - - public native @Const @ByRef btVector3 getPositionWorldOnA(); - - public native @Const @ByRef btVector3 getPositionWorldOnB(); - - public native void setDistance(@Cast("btScalar") float dist); - - /**this returns the most recent applied impulse, to satisfy contact constraints by the constraint solver */ - public native @Cast("btScalar") float getAppliedImpulse(); -} - -// #endif //BT_MANIFOLD_CONTACT_POINT_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H -// #define BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H - -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btVector3.h" - -/** This interface is made to be used by an iterative approach to do TimeOfImpact calculations - * This interface allows to query for closest points and penetration depth between two (convex) objects - * the closest point is on the second object (B), and the normal points from the surface on B towards A. - * distance is between closest points on B and closest point on A. So you can calculate closest point on A - * by taking closestPointInA = closestPointInB + m_distance * m_normalOnSurfaceB */ -public static class btDiscreteCollisionDetectorInterface extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDiscreteCollisionDetectorInterface(Pointer p) { super(p); } - - public static class Result extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public Result(Pointer p) { super(p); } - - - /**setShapeIdentifiersA/B provides experimental support for per-triangle material / custom material combiner */ - public native void setShapeIdentifiersA(int partId0, int index0); - public native void setShapeIdentifiersB(int partId1, int index1); - public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); - } - - @NoOffset public static class ClosestPointInput extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public ClosestPointInput(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public ClosestPointInput(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public ClosestPointInput position(long position) { - return (ClosestPointInput)super.position(position); - } - @Override public ClosestPointInput getPointer(long i) { - return new ClosestPointInput((Pointer)this).offsetAddress(i); - } - - public ClosestPointInput() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native @ByRef btTransform m_transformA(); public native ClosestPointInput m_transformA(btTransform setter); - public native @ByRef btTransform m_transformB(); public native ClosestPointInput m_transformB(btTransform setter); - public native @Cast("btScalar") float m_maximumDistanceSquared(); public native ClosestPointInput m_maximumDistanceSquared(float setter); - } - - // - // give either closest points (distance > 0) or penetration (distance) - // the normal always points from B towards A - // - public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw, @Cast("bool") boolean swapResults/*=false*/); - public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw); -} - -@NoOffset public static class btStorageResult extends btDiscreteCollisionDetectorInterface.Result { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btStorageResult(Pointer p) { super(p); } - - public native @ByRef btVector3 m_normalOnSurfaceB(); public native btStorageResult m_normalOnSurfaceB(btVector3 setter); - public native @ByRef btVector3 m_closestPointInB(); public native btStorageResult m_closestPointInB(btVector3 setter); - public native @Cast("btScalar") float m_distance(); public native btStorageResult m_distance(float setter); - - public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); -} - -// #endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H - - -// Parsed from BulletCollision/CollisionDispatch/btCollisionObject.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_COLLISION_OBJECT_H -// #define BT_COLLISION_OBJECT_H - -// #include "LinearMath/btTransform.h" - -//island management, m_activationState1 -public static final int ACTIVE_TAG = 1; -public static final int ISLAND_SLEEPING = 2; -public static final int WANTS_DEACTIVATION = 3; -public static final int DISABLE_DEACTIVATION = 4; -public static final int DISABLE_SIMULATION = 5; -public static final int FIXED_BASE_MULTI_BODY = 6; -// #include "LinearMath/btMotionState.h" -// #include "LinearMath/btAlignedAllocator.h" -// #include "LinearMath/btAlignedObjectArray.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btCollisionObjectData btCollisionObjectFloatData -public static final String btCollisionObjectDataName = "btCollisionObjectFloatData"; -// #endif - -/** btCollisionObject can be used to manage collision detection objects. - * btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy. - * They can be added to the btCollisionWorld. */ -@NoOffset public static class btCollisionObject extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionObject(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCollisionObject(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btCollisionObject position(long position) { - return (btCollisionObject)super.position(position); - } - @Override public btCollisionObject getPointer(long i) { - return new btCollisionObject((Pointer)this).offsetAddress(i); - } - - - /** enum btCollisionObject::CollisionFlags */ - public static final int - CF_DYNAMIC_OBJECT = 0, - CF_STATIC_OBJECT = 1, - CF_KINEMATIC_OBJECT = 2, - CF_NO_CONTACT_RESPONSE = 4, - CF_CUSTOM_MATERIAL_CALLBACK = 8, //this allows per-triangle material (friction/restitution) - CF_CHARACTER_OBJECT = 16, - CF_DISABLE_VISUALIZE_OBJECT = 32, //disable debug drawing - CF_DISABLE_SPU_COLLISION_PROCESSING = 64, //disable parallel/SPU processing - CF_HAS_CONTACT_STIFFNESS_DAMPING = 128, - CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256, - CF_HAS_FRICTION_ANCHOR = 512, - CF_HAS_COLLISION_SOUND_TRIGGER = 1024; - - /** enum btCollisionObject::CollisionObjectTypes */ - public static final int - CO_COLLISION_OBJECT = 1, - CO_RIGID_BODY = 2, - /**CO_GHOST_OBJECT keeps track of all objects overlapping its AABB and that pass its collision filter - * It is useful for collision sensors, explosion objects, character controller etc. */ - CO_GHOST_OBJECT = 4, - CO_SOFT_BODY = 8, - CO_HF_FLUID = 16, - CO_USER_TYPE = 32, - CO_FEATHERSTONE_LINK = 64; - - /** enum btCollisionObject::AnisotropicFrictionFlags */ - public static final int - CF_ANISOTROPIC_FRICTION_DISABLED = 0, - CF_ANISOTROPIC_FRICTION = 1, - CF_ANISOTROPIC_ROLLING_FRICTION = 2; - - public native @Cast("bool") boolean mergesSimulationIslands(); - - public native @Const @ByRef btVector3 getAnisotropicFriction(); - public native void setAnisotropicFriction(@Const @ByRef btVector3 anisotropicFriction, int frictionMode/*=btCollisionObject::CF_ANISOTROPIC_FRICTION*/); - public native void setAnisotropicFriction(@Const @ByRef btVector3 anisotropicFriction); - public native @Cast("bool") boolean hasAnisotropicFriction(int frictionMode/*=btCollisionObject::CF_ANISOTROPIC_FRICTION*/); - public native @Cast("bool") boolean hasAnisotropicFriction(); - - /**the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default. - * Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges */ - public native void setContactProcessingThreshold(@Cast("btScalar") float contactProcessingThreshold); - public native @Cast("btScalar") float getContactProcessingThreshold(); - - public native @Cast("bool") boolean isStaticObject(); - - public native @Cast("bool") boolean isKinematicObject(); - - public native @Cast("bool") boolean isStaticOrKinematicObject(); - - public native @Cast("bool") boolean hasContactResponse(); - - public btCollisionObject() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native void setCollisionShape(btCollisionShape collisionShape); - - public native btCollisionShape getCollisionShape(); - - public native void setIgnoreCollisionCheck(@Const btCollisionObject co, @Cast("bool") boolean ignoreCollisionCheck); - - public native int getNumObjectsWithoutCollision(); - - public native @Const btCollisionObject getObjectWithoutCollision(int index); - - public native @Cast("bool") boolean checkCollideWithOverride(@Const btCollisionObject co); - - /**Avoid using this internal API call, the extension pointer is used by some Bullet extensions. - * If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead. */ - public native Pointer internalGetExtensionPointer(); - /**Avoid using this internal API call, the extension pointer is used by some Bullet extensions - * If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead. */ - public native void internalSetExtensionPointer(Pointer pointer); - - public native int getActivationState(); - - public native void setActivationState(int newState); - - public native void setDeactivationTime(@Cast("btScalar") float time); - public native @Cast("btScalar") float getDeactivationTime(); - - public native void forceActivationState(int newState); - - public native void activate(@Cast("bool") boolean forceActivation/*=false*/); - public native void activate(); - - public native @Cast("bool") boolean isActive(); - - public native void setRestitution(@Cast("btScalar") float rest); - public native @Cast("btScalar") float getRestitution(); - public native void setFriction(@Cast("btScalar") float frict); - public native @Cast("btScalar") float getFriction(); - - public native void setRollingFriction(@Cast("btScalar") float frict); - public native @Cast("btScalar") float getRollingFriction(); - public native void setSpinningFriction(@Cast("btScalar") float frict); - public native @Cast("btScalar") float getSpinningFriction(); - public native void setContactStiffnessAndDamping(@Cast("btScalar") float stiffness, @Cast("btScalar") float damping); - - public native @Cast("btScalar") float getContactStiffness(); - - public native @Cast("btScalar") float getContactDamping(); - - /**reserved for Bullet internal usage */ - public native int getInternalType(); - - public native @ByRef btTransform getWorldTransform(); - - public native void setWorldTransform(@Const @ByRef btTransform worldTrans); - - public native btBroadphaseProxy getBroadphaseHandle(); - - public native void setBroadphaseHandle(btBroadphaseProxy handle); - - public native @ByRef btTransform getInterpolationWorldTransform(); - - public native void setInterpolationWorldTransform(@Const @ByRef btTransform trans); - - public native void setInterpolationLinearVelocity(@Const @ByRef btVector3 linvel); - - public native void setInterpolationAngularVelocity(@Const @ByRef btVector3 angvel); - - public native @Const @ByRef btVector3 getInterpolationLinearVelocity(); - - public native @Const @ByRef btVector3 getInterpolationAngularVelocity(); - - public native int getIslandTag(); - - public native void setIslandTag(int tag); - - public native int getCompanionId(); - - public native void setCompanionId(int id); - - public native int getWorldArrayIndex(); - - // only should be called by CollisionWorld - public native void setWorldArrayIndex(int ix); - - public native @Cast("btScalar") float getHitFraction(); - - public native void setHitFraction(@Cast("btScalar") float hitFraction); - - public native int getCollisionFlags(); - - public native void setCollisionFlags(int flags); - - /**Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: */ - public native @Cast("btScalar") float getCcdSweptSphereRadius(); - - /**Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: */ - public native void setCcdSweptSphereRadius(@Cast("btScalar") float radius); - - public native @Cast("btScalar") float getCcdMotionThreshold(); - - public native @Cast("btScalar") float getCcdSquareMotionThreshold(); - - /** Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold */ - public native void setCcdMotionThreshold(@Cast("btScalar") float ccdMotionThreshold); - - /**users can point to their objects, userPointer is not used by Bullet */ - public native Pointer getUserPointer(); - - public native int getUserIndex(); - - public native int getUserIndex2(); - - public native int getUserIndex3(); - - /**users can point to their objects, userPointer is not used by Bullet */ - public native void setUserPointer(Pointer userPointer); - - /**users can point to their objects, userPointer is not used by Bullet */ - public native void setUserIndex(int index); - - public native void setUserIndex2(int index); - - public native void setUserIndex3(int index); - - public native int getUpdateRevisionInternal(); - - public native void setCustomDebugColor(@Const @ByRef btVector3 colorRGB); - - public native void removeCustomDebugColor(); - - public native @Cast("bool") boolean getCustomDebugColor(@ByRef btVector3 colorRGB); - - public native @Cast("bool") boolean checkCollideWith(@Const btCollisionObject co); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); - - public native void serializeSingleObject(btSerializer serializer); -} - -// clang-format off - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btCollisionObjectDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCollisionObjectDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCollisionObjectDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionObjectDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCollisionObjectDoubleData position(long position) { - return (btCollisionObjectDoubleData)super.position(position); - } - @Override public btCollisionObjectDoubleData getPointer(long i) { - return new btCollisionObjectDoubleData((Pointer)this).offsetAddress(i); - } - - public native Pointer m_broadphaseHandle(); public native btCollisionObjectDoubleData m_broadphaseHandle(Pointer setter); - public native Pointer m_collisionShape(); public native btCollisionObjectDoubleData m_collisionShape(Pointer setter); - public native btCollisionShapeData m_rootCollisionShape(); public native btCollisionObjectDoubleData m_rootCollisionShape(btCollisionShapeData setter); - public native @Cast("char*") BytePointer m_name(); public native btCollisionObjectDoubleData m_name(BytePointer setter); - - public native @ByRef btTransformDoubleData m_worldTransform(); public native btCollisionObjectDoubleData m_worldTransform(btTransformDoubleData setter); - public native @ByRef btTransformDoubleData m_interpolationWorldTransform(); public native btCollisionObjectDoubleData m_interpolationWorldTransform(btTransformDoubleData setter); - public native @ByRef btVector3DoubleData m_interpolationLinearVelocity(); public native btCollisionObjectDoubleData m_interpolationLinearVelocity(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_interpolationAngularVelocity(); public native btCollisionObjectDoubleData m_interpolationAngularVelocity(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_anisotropicFriction(); public native btCollisionObjectDoubleData m_anisotropicFriction(btVector3DoubleData setter); - public native double m_contactProcessingThreshold(); public native btCollisionObjectDoubleData m_contactProcessingThreshold(double setter); - public native double m_deactivationTime(); public native btCollisionObjectDoubleData m_deactivationTime(double setter); - public native double m_friction(); public native btCollisionObjectDoubleData m_friction(double setter); - public native double m_rollingFriction(); public native btCollisionObjectDoubleData m_rollingFriction(double setter); - public native double m_contactDamping(); public native btCollisionObjectDoubleData m_contactDamping(double setter); - public native double m_contactStiffness(); public native btCollisionObjectDoubleData m_contactStiffness(double setter); - public native double m_restitution(); public native btCollisionObjectDoubleData m_restitution(double setter); - public native double m_hitFraction(); public native btCollisionObjectDoubleData m_hitFraction(double setter); - public native double m_ccdSweptSphereRadius(); public native btCollisionObjectDoubleData m_ccdSweptSphereRadius(double setter); - public native double m_ccdMotionThreshold(); public native btCollisionObjectDoubleData m_ccdMotionThreshold(double setter); - public native int m_hasAnisotropicFriction(); public native btCollisionObjectDoubleData m_hasAnisotropicFriction(int setter); - public native int m_collisionFlags(); public native btCollisionObjectDoubleData m_collisionFlags(int setter); - public native int m_islandTag1(); public native btCollisionObjectDoubleData m_islandTag1(int setter); - public native int m_companionId(); public native btCollisionObjectDoubleData m_companionId(int setter); - public native int m_activationState1(); public native btCollisionObjectDoubleData m_activationState1(int setter); - public native int m_internalType(); public native btCollisionObjectDoubleData m_internalType(int setter); - public native int m_checkCollideWith(); public native btCollisionObjectDoubleData m_checkCollideWith(int setter); - public native int m_collisionFilterGroup(); public native btCollisionObjectDoubleData m_collisionFilterGroup(int setter); - public native int m_collisionFilterMask(); public native btCollisionObjectDoubleData m_collisionFilterMask(int setter); - public native int m_uniqueId(); public native btCollisionObjectDoubleData m_uniqueId(int setter);//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btCollisionObjectFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCollisionObjectFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCollisionObjectFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionObjectFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCollisionObjectFloatData position(long position) { - return (btCollisionObjectFloatData)super.position(position); - } - @Override public btCollisionObjectFloatData getPointer(long i) { - return new btCollisionObjectFloatData((Pointer)this).offsetAddress(i); - } - - public native Pointer m_broadphaseHandle(); public native btCollisionObjectFloatData m_broadphaseHandle(Pointer setter); - public native Pointer m_collisionShape(); public native btCollisionObjectFloatData m_collisionShape(Pointer setter); - public native btCollisionShapeData m_rootCollisionShape(); public native btCollisionObjectFloatData m_rootCollisionShape(btCollisionShapeData setter); - public native @Cast("char*") BytePointer m_name(); public native btCollisionObjectFloatData m_name(BytePointer setter); - - public native @ByRef btTransformFloatData m_worldTransform(); public native btCollisionObjectFloatData m_worldTransform(btTransformFloatData setter); - public native @ByRef btTransformFloatData m_interpolationWorldTransform(); public native btCollisionObjectFloatData m_interpolationWorldTransform(btTransformFloatData setter); - public native @ByRef btVector3FloatData m_interpolationLinearVelocity(); public native btCollisionObjectFloatData m_interpolationLinearVelocity(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_interpolationAngularVelocity(); public native btCollisionObjectFloatData m_interpolationAngularVelocity(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_anisotropicFriction(); public native btCollisionObjectFloatData m_anisotropicFriction(btVector3FloatData setter); - public native float m_contactProcessingThreshold(); public native btCollisionObjectFloatData m_contactProcessingThreshold(float setter); - public native float m_deactivationTime(); public native btCollisionObjectFloatData m_deactivationTime(float setter); - public native float m_friction(); public native btCollisionObjectFloatData m_friction(float setter); - public native float m_rollingFriction(); public native btCollisionObjectFloatData m_rollingFriction(float setter); - public native float m_contactDamping(); public native btCollisionObjectFloatData m_contactDamping(float setter); - public native float m_contactStiffness(); public native btCollisionObjectFloatData m_contactStiffness(float setter); - public native float m_restitution(); public native btCollisionObjectFloatData m_restitution(float setter); - public native float m_hitFraction(); public native btCollisionObjectFloatData m_hitFraction(float setter); - public native float m_ccdSweptSphereRadius(); public native btCollisionObjectFloatData m_ccdSweptSphereRadius(float setter); - public native float m_ccdMotionThreshold(); public native btCollisionObjectFloatData m_ccdMotionThreshold(float setter); - public native int m_hasAnisotropicFriction(); public native btCollisionObjectFloatData m_hasAnisotropicFriction(int setter); - public native int m_collisionFlags(); public native btCollisionObjectFloatData m_collisionFlags(int setter); - public native int m_islandTag1(); public native btCollisionObjectFloatData m_islandTag1(int setter); - public native int m_companionId(); public native btCollisionObjectFloatData m_companionId(int setter); - public native int m_activationState1(); public native btCollisionObjectFloatData m_activationState1(int setter); - public native int m_internalType(); public native btCollisionObjectFloatData m_internalType(int setter); - public native int m_checkCollideWith(); public native btCollisionObjectFloatData m_checkCollideWith(int setter); - public native int m_collisionFilterGroup(); public native btCollisionObjectFloatData m_collisionFilterGroup(int setter); - public native int m_collisionFilterMask(); public native btCollisionObjectFloatData m_collisionFilterMask(int setter); - public native int m_uniqueId(); public native btCollisionObjectFloatData m_uniqueId(int setter); -} -// clang-format on - - - -// #endif //BT_COLLISION_OBJECT_H - - -// Parsed from BulletCollision/CollisionDispatch/btCollisionCreateFunc.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_COLLISION_CREATE_FUNC -// #define BT_COLLISION_CREATE_FUNC - -// #include "LinearMath/btAlignedObjectArray.h" -@Opaque public static class btCollisionAlgorithmConstructionInfo extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionAlgorithmConstructionInfo() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionAlgorithmConstructionInfo(Pointer p) { super(p); } -} - -/**Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm */ -@NoOffset public static class btCollisionAlgorithmCreateFunc extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionAlgorithmCreateFunc(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCollisionAlgorithmCreateFunc(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btCollisionAlgorithmCreateFunc position(long position) { - return (btCollisionAlgorithmCreateFunc)super.position(position); - } - @Override public btCollisionAlgorithmCreateFunc getPointer(long i) { - return new btCollisionAlgorithmCreateFunc((Pointer)this).offsetAddress(i); - } - - public native @Cast("bool") boolean m_swapped(); public native btCollisionAlgorithmCreateFunc m_swapped(boolean setter); - - public btCollisionAlgorithmCreateFunc() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo arg0, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); -} -// #endif //BT_COLLISION_CREATE_FUNC - - -// Parsed from BulletCollision/CollisionDispatch/btCollisionDispatcher.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_COLLISION__DISPATCHER_H -// #define BT_COLLISION__DISPATCHER_H - -// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" -// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" - -// #include "BulletCollision/CollisionDispatch/btManifoldResult.h" - -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "LinearMath/btAlignedObjectArray.h" -@Opaque public static class btCollisionConfiguration extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionConfiguration() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionConfiguration(Pointer p) { super(p); } -} - -// #include "btCollisionCreateFunc.h" - -public static final int USE_DISPATCH_REGISTRY_ARRAY = 1; -/**user can override this nearcallback for collision filtering and more finegrained control over collision detection */ -public static class btNearCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btNearCallback(Pointer p) { super(p); } - protected btNearCallback() { allocate(); } - private native void allocate(); - public native void call(@ByRef btBroadphasePair collisionPair, @ByRef btCollisionDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); -} - -/**btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs. - * Time of Impact, Closest Points and Penetration Depth. */ -@NoOffset public static class btCollisionDispatcher extends btDispatcher { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionDispatcher(Pointer p) { super(p); } - - /** enum btCollisionDispatcher::DispatcherFlags */ - public static final int - CD_STATIC_STATIC_REPORTED = 1, - CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD = 2, - CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION = 4; - - public native int getDispatcherFlags(); - - public native void setDispatcherFlags(int flags); - - /**registerCollisionCreateFunc allows registration of custom/alternative collision create functions */ - public native void registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc createFunc); - - public native void registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc createFunc); - - public native int getNumManifolds(); - - public native @Cast("btPersistentManifold**") PointerPointer getInternalManifoldPointer(); - - public native btPersistentManifold getManifoldByIndexInternal(int index); - - public btCollisionDispatcher(btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(collisionConfiguration); } - private native void allocate(btCollisionConfiguration collisionConfiguration); - - public native btPersistentManifold getNewManifold(@Const btCollisionObject b0, @Const btCollisionObject b1); - - public native void releaseManifold(btPersistentManifold manifold); - - public native void clearManifold(btPersistentManifold manifold); - - public native btCollisionAlgorithm findAlgorithm(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold, @Cast("ebtDispatcherQueryType") int queryType); - - public native @Cast("bool") boolean needsCollision(@Const btCollisionObject body0, @Const btCollisionObject body1); - - public native @Cast("bool") boolean needsResponse(@Const btCollisionObject body0, @Const btCollisionObject body1); - - public native void dispatchAllCollisionPairs(btOverlappingPairCache pairCache, @Const @ByRef btDispatcherInfo dispatchInfo, btDispatcher dispatcher); - - public native void setNearCallback(btNearCallback nearCallback); - - public native btNearCallback getNearCallback(); - - //by default, Bullet will use this near callback - public static native void defaultNearCallback(@ByRef btBroadphasePair collisionPair, @ByRef btCollisionDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); - - public native Pointer allocateCollisionAlgorithm(int size); - - public native void freeCollisionAlgorithm(Pointer ptr); - - public native btCollisionConfiguration getCollisionConfiguration(); - - public native void setCollisionConfiguration(btCollisionConfiguration config); - - public native btPoolAllocator getInternalManifoldPool(); -} - -// #endif //BT_COLLISION__DISPATCHER_H - - -// Parsed from BulletCollision/CollisionDispatch/btCollisionWorld.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -/** - * \mainpage Bullet Documentation - * - * \section intro_sec Introduction - * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ). - * - * The main documentation is Bullet_User_Manual.pdf, included in the source code distribution. - * There is the Physics Forum for feedback and general Collision Detection and Physics discussions. - * Please visit http://www.bulletphysics.org - * - * \section install_sec Installation - * - * \subsection step1 Step 1: Download - * You can download the Bullet Physics Library from the github repository: https://github.com/bulletphysics/bullet3/releases - * - * \subsection step2 Step 2: Building - * Bullet has multiple build systems, including premake, cmake and autotools. Premake and cmake support all platforms. - * Premake is included in the Bullet/build folder for Windows, Mac OSX and Linux. - * Under Windows you can click on Bullet/build/vs2010.bat to create Microsoft Visual Studio projects. - * On Mac OSX and Linux you can open a terminal and generate Makefile, codeblocks or Xcode4 projects: - * cd Bullet/build - * ./premake4_osx gmake or ./premake4_linux gmake or ./premake4_linux64 gmake or (for Mac) ./premake4_osx xcode4 - * cd Bullet/build/gmake - * make - * - * An alternative to premake is cmake. You can download cmake from http://www.cmake.org - * cmake can autogenerate projectfiles for Microsoft Visual Studio, Apple Xcode, KDevelop and Unix Makefiles. - * The easiest is to run the CMake cmake-gui graphical user interface and choose the options and generate projectfiles. - * You can also use cmake in the command-line. Here are some examples for various platforms: - * cmake . -G "Visual Studio 9 2008" - * cmake . -G Xcode - * cmake . -G "Unix Makefiles" - * Although cmake is recommended, you can also use autotools for UNIX: ./autogen.sh ./configure to create a Makefile and then run make. - * - * \subsection step3 Step 3: Testing demos - * Try to run and experiment with BasicDemo executable as a starting point. - * Bullet can be used in several ways, as Full Rigid Body simulation, as Collision Detector Library or Low Level / Snippets like the GJK Closest Point calculation. - * The Dependencies can be seen in this documentation under Directories - * - * \subsection step4 Step 4: Integrating in your application, full Rigid Body and Soft Body simulation - * Check out BasicDemo how to create a btDynamicsWorld, btRigidBody and btCollisionShape, Stepping the simulation and synchronizing your graphics object transform. - * Check out SoftDemo how to use soft body dynamics, using btSoftRigidDynamicsWorld. - * \subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras) - * Bullet Collision Detection can also be used without the Dynamics/Extras. - * Check out btCollisionWorld and btCollisionObject, and the CollisionInterfaceDemo. - * \subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation. - * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of btGjkPairDetector. - * - * \section copyright Copyright - * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf - * - */ - -// #ifndef BT_COLLISION_WORLD_H -// #define BT_COLLISION_WORLD_H -@Opaque public static class btConvexShape extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btConvexShape() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexShape(Pointer p) { super(p); } -} - -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "btCollisionObject.h" -// #include "btCollisionDispatcher.h" -// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" -// #include "LinearMath/btAlignedObjectArray.h" - -/**CollisionWorld is interface and container for the collision detection */ -@NoOffset public static class btCollisionWorld extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionWorld(Pointer p) { super(p); } - - //this constructor doesn't own the dispatcher and paircache/broadphase - public btCollisionWorld(btDispatcher dispatcher, btBroadphaseInterface broadphasePairCache, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, broadphasePairCache, collisionConfiguration); } - private native void allocate(btDispatcher dispatcher, btBroadphaseInterface broadphasePairCache, btCollisionConfiguration collisionConfiguration); - - public native void setBroadphase(btBroadphaseInterface pairCache); - - public native btBroadphaseInterface getBroadphase(); - - public native btOverlappingPairCache getPairCache(); - - public native btDispatcher getDispatcher(); - - public native void updateSingleAabb(btCollisionObject colObj); - - public native void updateAabbs(); - - /**the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSimulation) - * it can be useful to use if you perform ray tests without collision detection/simulation */ - public native void computeOverlappingPairs(); - - public native void setDebugDrawer(btIDebugDraw debugDrawer); - - public native btIDebugDraw getDebugDrawer(); - - public native void debugDrawWorld(); - - public native void debugDrawObject(@Const @ByRef btTransform worldTransform, @Const btCollisionShape shape, @Const @ByRef btVector3 color); - - /**LocalShapeInfo gives extra information for complex shapes - * Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart */ - public static class LocalShapeInfo extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public LocalShapeInfo() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public LocalShapeInfo(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public LocalShapeInfo(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public LocalShapeInfo position(long position) { - return (LocalShapeInfo)super.position(position); - } - @Override public LocalShapeInfo getPointer(long i) { - return new LocalShapeInfo((Pointer)this).offsetAddress(i); - } - - public native int m_shapePart(); public native LocalShapeInfo m_shapePart(int setter); - public native int m_triangleIndex(); public native LocalShapeInfo m_triangleIndex(int setter); - - //const btCollisionShape* m_shapeTemp; - //const btTransform* m_shapeLocalTransform; - } - - @NoOffset public static class LocalRayResult extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public LocalRayResult(Pointer p) { super(p); } - - public LocalRayResult(@Const btCollisionObject collisionObject, - LocalShapeInfo localShapeInfo, - @Const @ByRef btVector3 hitNormalLocal, - @Cast("btScalar") float hitFraction) { super((Pointer)null); allocate(collisionObject, localShapeInfo, hitNormalLocal, hitFraction); } - private native void allocate(@Const btCollisionObject collisionObject, - LocalShapeInfo localShapeInfo, - @Const @ByRef btVector3 hitNormalLocal, - @Cast("btScalar") float hitFraction); - - public native @Const btCollisionObject m_collisionObject(); public native LocalRayResult m_collisionObject(btCollisionObject setter); - public native LocalShapeInfo m_localShapeInfo(); public native LocalRayResult m_localShapeInfo(LocalShapeInfo setter); - public native @ByRef btVector3 m_hitNormalLocal(); public native LocalRayResult m_hitNormalLocal(btVector3 setter); - public native @Cast("btScalar") float m_hitFraction(); public native LocalRayResult m_hitFraction(float setter); - } - - /**RayResultCallback is used to report new raycast results */ - @NoOffset public static class RayResultCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public RayResultCallback(Pointer p) { super(p); } - - public native @Cast("btScalar") float m_closestHitFraction(); public native RayResultCallback m_closestHitFraction(float setter); - public native @Const btCollisionObject m_collisionObject(); public native RayResultCallback m_collisionObject(btCollisionObject setter); - public native int m_collisionFilterGroup(); public native RayResultCallback m_collisionFilterGroup(int setter); - public native int m_collisionFilterMask(); public native RayResultCallback m_collisionFilterMask(int setter); - //@BP Mod - Custom flags, currently used to enable backface culling on tri-meshes, see btRaycastCallback.h. Apply any of the EFlags defined there on m_flags here to invoke. - public native @Cast("unsigned int") int m_flags(); public native RayResultCallback m_flags(int setter); - public native @Cast("bool") boolean hasHit(); - - public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); - - public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); - } - - @NoOffset public static class ClosestRayResultCallback extends RayResultCallback { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public ClosestRayResultCallback(Pointer p) { super(p); } - - public ClosestRayResultCallback(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld) { super((Pointer)null); allocate(rayFromWorld, rayToWorld); } - private native void allocate(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld); - - public native @ByRef btVector3 m_rayFromWorld(); public native ClosestRayResultCallback m_rayFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction - public native @ByRef btVector3 m_rayToWorld(); public native ClosestRayResultCallback m_rayToWorld(btVector3 setter); - - public native @ByRef btVector3 m_hitNormalWorld(); public native ClosestRayResultCallback m_hitNormalWorld(btVector3 setter); - public native @ByRef btVector3 m_hitPointWorld(); public native ClosestRayResultCallback m_hitPointWorld(btVector3 setter); - - public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); - } - - @NoOffset public static class AllHitsRayResultCallback extends RayResultCallback { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public AllHitsRayResultCallback(Pointer p) { super(p); } - - public AllHitsRayResultCallback(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld) { super((Pointer)null); allocate(rayFromWorld, rayToWorld); } - private native void allocate(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld); - - - - public native @ByRef btVector3 m_rayFromWorld(); public native AllHitsRayResultCallback m_rayFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction - public native @ByRef btVector3 m_rayToWorld(); public native AllHitsRayResultCallback m_rayToWorld(btVector3 setter); - - public native @ByRef btAlignedObjectArray_btVector3 m_hitNormalWorld(); public native AllHitsRayResultCallback m_hitNormalWorld(btAlignedObjectArray_btVector3 setter); - public native @ByRef btAlignedObjectArray_btVector3 m_hitPointWorld(); public native AllHitsRayResultCallback m_hitPointWorld(btAlignedObjectArray_btVector3 setter); - public native @ByRef btAlignedObjectArray_btScalar m_hitFractions(); public native AllHitsRayResultCallback m_hitFractions(btAlignedObjectArray_btScalar setter); - - public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); - } - - @NoOffset public static class LocalConvexResult extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public LocalConvexResult(Pointer p) { super(p); } - - public LocalConvexResult(@Const btCollisionObject hitCollisionObject, - LocalShapeInfo localShapeInfo, - @Const @ByRef btVector3 hitNormalLocal, - @Const @ByRef btVector3 hitPointLocal, - @Cast("btScalar") float hitFraction) { super((Pointer)null); allocate(hitCollisionObject, localShapeInfo, hitNormalLocal, hitPointLocal, hitFraction); } - private native void allocate(@Const btCollisionObject hitCollisionObject, - LocalShapeInfo localShapeInfo, - @Const @ByRef btVector3 hitNormalLocal, - @Const @ByRef btVector3 hitPointLocal, - @Cast("btScalar") float hitFraction); - - public native @Const btCollisionObject m_hitCollisionObject(); public native LocalConvexResult m_hitCollisionObject(btCollisionObject setter); - public native LocalShapeInfo m_localShapeInfo(); public native LocalConvexResult m_localShapeInfo(LocalShapeInfo setter); - public native @ByRef btVector3 m_hitNormalLocal(); public native LocalConvexResult m_hitNormalLocal(btVector3 setter); - public native @ByRef btVector3 m_hitPointLocal(); public native LocalConvexResult m_hitPointLocal(btVector3 setter); - public native @Cast("btScalar") float m_hitFraction(); public native LocalConvexResult m_hitFraction(float setter); - } - - /**RayResultCallback is used to report new raycast results */ - @NoOffset public static class ConvexResultCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public ConvexResultCallback(Pointer p) { super(p); } - - public native @Cast("btScalar") float m_closestHitFraction(); public native ConvexResultCallback m_closestHitFraction(float setter); - public native int m_collisionFilterGroup(); public native ConvexResultCallback m_collisionFilterGroup(int setter); - public native int m_collisionFilterMask(); public native ConvexResultCallback m_collisionFilterMask(int setter); - - public native @Cast("bool") boolean hasHit(); - - public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); - - public native @Cast("btScalar") float addSingleResult(@ByRef LocalConvexResult convexResult, @Cast("bool") boolean normalInWorldSpace); - } - - @NoOffset public static class ClosestConvexResultCallback extends ConvexResultCallback { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public ClosestConvexResultCallback(Pointer p) { super(p); } - - public ClosestConvexResultCallback(@Const @ByRef btVector3 convexFromWorld, @Const @ByRef btVector3 convexToWorld) { super((Pointer)null); allocate(convexFromWorld, convexToWorld); } - private native void allocate(@Const @ByRef btVector3 convexFromWorld, @Const @ByRef btVector3 convexToWorld); - - public native @ByRef btVector3 m_convexFromWorld(); public native ClosestConvexResultCallback m_convexFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction - public native @ByRef btVector3 m_convexToWorld(); public native ClosestConvexResultCallback m_convexToWorld(btVector3 setter); - - public native @ByRef btVector3 m_hitNormalWorld(); public native ClosestConvexResultCallback m_hitNormalWorld(btVector3 setter); - public native @ByRef btVector3 m_hitPointWorld(); public native ClosestConvexResultCallback m_hitPointWorld(btVector3 setter); - public native @Const btCollisionObject m_hitCollisionObject(); public native ClosestConvexResultCallback m_hitCollisionObject(btCollisionObject setter); - - public native @Cast("btScalar") float addSingleResult(@ByRef LocalConvexResult convexResult, @Cast("bool") boolean normalInWorldSpace); - } - - /**ContactResultCallback is used to report contact points */ - @NoOffset public static class ContactResultCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public ContactResultCallback(Pointer p) { super(p); } - - public native int m_collisionFilterGroup(); public native ContactResultCallback m_collisionFilterGroup(int setter); - public native int m_collisionFilterMask(); public native ContactResultCallback m_collisionFilterMask(int setter); - public native @Cast("btScalar") float m_closestDistanceThreshold(); public native ContactResultCallback m_closestDistanceThreshold(float setter); - - public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); - - public native @Cast("btScalar") float addSingleResult(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper colObj0Wrap, int partId0, int index0, @Const btCollisionObjectWrapper colObj1Wrap, int partId1, int index1); - } - - public native int getNumCollisionObjects(); - - /** rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback - * This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback. */ - public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); - - /** convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback - * This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback. */ - public native void convexSweepTest(@Const btConvexShape castShape, @Const @ByRef btTransform from, @Const @ByRef btTransform to, @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedCcdPenetration/*=btScalar(0.)*/); - public native void convexSweepTest(@Const btConvexShape castShape, @Const @ByRef btTransform from, @Const @ByRef btTransform to, @ByRef ConvexResultCallback resultCallback); - - /**contactTest performs a discrete collision test between colObj against all objects in the btCollisionWorld, and calls the resultCallback. - * it reports one or more contact points for every overlapping object (including the one with deepest penetration) */ - public native void contactTest(btCollisionObject colObj, @ByRef ContactResultCallback resultCallback); - - /**contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected. - * it reports one or more contact points (including the one with deepest penetration) */ - public native void contactPairTest(btCollisionObject colObjA, btCollisionObject colObjB, @ByRef ContactResultCallback resultCallback); - - /** rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest. - * In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape. - * This allows more customization. */ - public static native void rayTestSingle(@Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, - btCollisionObject collisionObject, - @Const btCollisionShape collisionShape, - @Const @ByRef btTransform colObjWorldTransform, - @ByRef RayResultCallback resultCallback); - - public static native void rayTestSingleInternal(@Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, - @Const btCollisionObjectWrapper collisionObjectWrap, - @ByRef RayResultCallback resultCallback); - - /** objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest. */ - public static native void objectQuerySingle(@Const btConvexShape castShape, @Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, - btCollisionObject collisionObject, - @Const btCollisionShape collisionShape, - @Const @ByRef btTransform colObjWorldTransform, - @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedPenetration); - - public static native void objectQuerySingleInternal(@Const btConvexShape castShape, @Const @ByRef btTransform convexFromTrans, @Const @ByRef btTransform convexToTrans, - @Const btCollisionObjectWrapper colObjWrap, - @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedPenetration); - - public native void addCollisionObject(btCollisionObject collisionObject, int collisionFilterGroup/*=btBroadphaseProxy::DefaultFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter*/); - public native void addCollisionObject(btCollisionObject collisionObject); - - public native void refreshBroadphaseProxy(btCollisionObject collisionObject); - - public native @Cast("btCollisionObjectArray*") @ByRef btAlignedObjectArray_btVector3 getCollisionObjectArray(); - - public native void removeCollisionObject(btCollisionObject collisionObject); - - public native void performDiscreteCollisionDetection(); - - public native @ByRef btDispatcherInfo getDispatchInfo(); - - public native @Cast("bool") boolean getForceUpdateAllAabbs(); - public native void setForceUpdateAllAabbs(@Cast("bool") boolean forceUpdateAllAabbs); - - /**Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bullet/Demos/SerializeDemo) */ - public native void serialize(btSerializer serializer); -} - -// #endif //BT_COLLISION_WORLD_H - - -// Parsed from BulletCollision/CollisionDispatch/btManifoldResult.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_MANIFOLD_RESULT_H -// #define BT_MANIFOLD_RESULT_H - -// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" - -// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" - -// #include "LinearMath/btTransform.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" - -public static class ContactAddedCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public ContactAddedCallback(Pointer p) { super(p); } - protected ContactAddedCallback() { allocate(); } - private native void allocate(); - public native @Cast("bool") boolean call(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper colObj0Wrap, int partId0, int index0, @Const btCollisionObjectWrapper colObj1Wrap, int partId1, int index1); -} -public static native ContactAddedCallback gContactAddedCallback(); public static native void gContactAddedCallback(ContactAddedCallback setter); - -//#define DEBUG_PART_INDEX 1 - -/** These callbacks are used to customize the algorith that combine restitution, friction, damping, Stiffness */ -public static class CalculateCombinedCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public CalculateCombinedCallback(Pointer p) { super(p); } - protected CalculateCombinedCallback() { allocate(); } - private native void allocate(); - public native @Cast("btScalar") float call(@Const btCollisionObject body0, @Const btCollisionObject body1); -} - -public static native CalculateCombinedCallback gCalculateCombinedRestitutionCallback(); public static native void gCalculateCombinedRestitutionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedFrictionCallback(); public static native void gCalculateCombinedFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback(); public static native void gCalculateCombinedRollingFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback(); public static native void gCalculateCombinedSpinningFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedContactDampingCallback(); public static native void gCalculateCombinedContactDampingCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback(); public static native void gCalculateCombinedContactStiffnessCallback(CalculateCombinedCallback setter); - -/**btManifoldResult is a helper class to manage contact results. */ -@NoOffset public static class btManifoldResult extends btDiscreteCollisionDetectorInterface.Result { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btManifoldResult(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btManifoldResult(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btManifoldResult position(long position) { - return (btManifoldResult)super.position(position); - } - @Override public btManifoldResult getPointer(long i) { - return new btManifoldResult((Pointer)this).offsetAddress(i); - } - - public btManifoldResult() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btManifoldResult(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap) { super((Pointer)null); allocate(body0Wrap, body1Wrap); } - private native void allocate(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); - - public native void setPersistentManifold(btPersistentManifold manifoldPtr); - public native btPersistentManifold getPersistentManifold(); - - public native void setShapeIdentifiersA(int partId0, int index0); - - public native void setShapeIdentifiersB(int partId1, int index1); - - public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); - - public native void refreshContactPoints(); - - public native @Const btCollisionObjectWrapper getBody0Wrap(); - public native @Const btCollisionObjectWrapper getBody1Wrap(); - - public native void setBody0Wrap(@Const btCollisionObjectWrapper obj0Wrap); - - public native void setBody1Wrap(@Const btCollisionObjectWrapper obj1Wrap); - - public native @Const btCollisionObject getBody0Internal(); - - public native @Const btCollisionObject getBody1Internal(); - - public native @Cast("btScalar") float m_closestPointDistanceThreshold(); public native btManifoldResult m_closestPointDistanceThreshold(float setter); - - /** in the future we can let the user override the methods to combine restitution and friction */ - public static native @Cast("btScalar") float calculateCombinedRestitution(@Const btCollisionObject body0, @Const btCollisionObject body1); - public static native @Cast("btScalar") float calculateCombinedFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); - public static native @Cast("btScalar") float calculateCombinedRollingFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); - public static native @Cast("btScalar") float calculateCombinedSpinningFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); - public static native @Cast("btScalar") float calculateCombinedContactDamping(@Const btCollisionObject body0, @Const btCollisionObject body1); - public static native @Cast("btScalar") float calculateCombinedContactStiffness(@Const btCollisionObject body0, @Const btCollisionObject body1); -} - -// #endif //BT_MANIFOLD_RESULT_H - - -// Parsed from BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H -// #define __BT_ACTIVATING_COLLISION_ALGORITHM_H - -// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" - -/**This class is not enabled yet (work-in-progress) to more aggressively activate objects. */ -public static class btActivatingCollisionAlgorithm extends btCollisionAlgorithm { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btActivatingCollisionAlgorithm(Pointer p) { super(p); } - -} -// #endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H - - -// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H -// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H - -// #include "btActivatingCollisionAlgorithm.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" -// #include "btCollisionDispatcher.h" - -/** btSphereSphereCollisionAlgorithm provides sphere-sphere collision detection. - * Other features are frame-coherency (persistent data) and collision response. - * Also provides the most basic sample for custom/user btCollisionAlgorithm */ -@NoOffset public static class btSphereSphereCollisionAlgorithm extends btActivatingCollisionAlgorithm { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSphereSphereCollisionAlgorithm(Pointer p) { super(p); } - - public btSphereSphereCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap) { super((Pointer)null); allocate(mf, ci, col0Wrap, col1Wrap); } - private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap); - - public btSphereSphereCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci) { super((Pointer)null); allocate(ci); } - private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci); - - public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); - - public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); - - - - public static class CreateFunc extends btCollisionAlgorithmCreateFunc { - static { Loader.load(); } - /** Default native constructor. */ - public CreateFunc() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public CreateFunc(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public CreateFunc position(long position) { - return (CreateFunc)super.position(position); - } - @Override public CreateFunc getPointer(long i) { - return new CreateFunc((Pointer)this).offsetAddress(i); - } - - public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap); - } -} - -// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H - - -// Parsed from BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_DEFAULT_COLLISION_CONFIGURATION -// #define BT_DEFAULT_COLLISION_CONFIGURATION - -// #include "btCollisionConfiguration.h" -@Opaque public static class btVoronoiSimplexSolver extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btVoronoiSimplexSolver() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVoronoiSimplexSolver(Pointer p) { super(p); } -} -@Opaque public static class btConvexPenetrationDepthSolver extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btConvexPenetrationDepthSolver() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexPenetrationDepthSolver(Pointer p) { super(p); } -} - -@NoOffset public static class btDefaultCollisionConstructionInfo extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDefaultCollisionConstructionInfo(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btDefaultCollisionConstructionInfo(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btDefaultCollisionConstructionInfo position(long position) { - return (btDefaultCollisionConstructionInfo)super.position(position); - } - @Override public btDefaultCollisionConstructionInfo getPointer(long i) { - return new btDefaultCollisionConstructionInfo((Pointer)this).offsetAddress(i); - } - - public native btPoolAllocator m_persistentManifoldPool(); public native btDefaultCollisionConstructionInfo m_persistentManifoldPool(btPoolAllocator setter); - public native btPoolAllocator m_collisionAlgorithmPool(); public native btDefaultCollisionConstructionInfo m_collisionAlgorithmPool(btPoolAllocator setter); - public native int m_defaultMaxPersistentManifoldPoolSize(); public native btDefaultCollisionConstructionInfo m_defaultMaxPersistentManifoldPoolSize(int setter); - public native int m_defaultMaxCollisionAlgorithmPoolSize(); public native btDefaultCollisionConstructionInfo m_defaultMaxCollisionAlgorithmPoolSize(int setter); - public native int m_customCollisionAlgorithmMaxElementSize(); public native btDefaultCollisionConstructionInfo m_customCollisionAlgorithmMaxElementSize(int setter); - public native int m_useEpaPenetrationAlgorithm(); public native btDefaultCollisionConstructionInfo m_useEpaPenetrationAlgorithm(int setter); - - public btDefaultCollisionConstructionInfo() { super((Pointer)null); allocate(); } - private native void allocate(); -} - -/**btCollisionConfiguration allows to configure Bullet collision detection - * stack allocator, pool memory allocators - * \todo: describe the meaning */ -@NoOffset public static class btDefaultCollisionConfiguration extends btCollisionConfiguration { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDefaultCollisionConfiguration(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btDefaultCollisionConfiguration(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btDefaultCollisionConfiguration position(long position) { - return (btDefaultCollisionConfiguration)super.position(position); - } - @Override public btDefaultCollisionConfiguration getPointer(long i) { - return new btDefaultCollisionConfiguration((Pointer)this).offsetAddress(i); - } - - public btDefaultCollisionConfiguration(@Const @ByRef(nullValue = "btDefaultCollisionConstructionInfo()") btDefaultCollisionConstructionInfo constructionInfo) { super((Pointer)null); allocate(constructionInfo); } - private native void allocate(@Const @ByRef(nullValue = "btDefaultCollisionConstructionInfo()") btDefaultCollisionConstructionInfo constructionInfo); - public btDefaultCollisionConfiguration() { super((Pointer)null); allocate(); } - private native void allocate(); - - /**memory pools */ - public native btPoolAllocator getPersistentManifoldPool(); - - public native btPoolAllocator getCollisionAlgorithmPool(); - - public native btCollisionAlgorithmCreateFunc getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1); - - public native btCollisionAlgorithmCreateFunc getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1); - - /**Use this method to allow to generate multiple contact points between at once, between two objects using the generic convex-convex algorithm. - * By default, this feature is disabled for best performance. - * @param numPerturbationIterations controls the number of collision queries. Set it to zero to disable the feature. - * @param minimumPointsPerturbationThreshold is the minimum number of points in the contact cache, above which the feature is disabled - * 3 is a good value for both params, if you want to enable the feature. This is because the default contact cache contains a maximum of 4 points, and one collision query at the unperturbed orientation is performed first. - * See Bullet/Demos/CollisionDemo for an example how this feature gathers multiple points. - * \todo we could add a per-object setting of those parameters, for level-of-detail collision detection. */ - public native void setConvexConvexMultipointIterations(int numPerturbationIterations/*=3*/, int minimumPointsPerturbationThreshold/*=3*/); - public native void setConvexConvexMultipointIterations(); - - public native void setPlaneConvexMultipointIterations(int numPerturbationIterations/*=3*/, int minimumPointsPerturbationThreshold/*=3*/); - public native void setPlaneConvexMultipointIterations(); -} - -// #endif //BT_DEFAULT_COLLISION_CONFIGURATION - - -// Parsed from BulletCollision/CollisionShapes/btCollisionShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_COLLISION_SHAPE_H -// #define BT_COLLISION_SHAPE_H - -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types - -/**The btCollisionShape class provides an interface for collision shapes that can be shared among btCollisionObjects. */ -@NoOffset public static class btCollisionShape extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionShape(Pointer p) { super(p); } - - - /**getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t. */ - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef FloatPointer radius); - public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef FloatBuffer radius); - public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef float[] radius); - - /**getAngularMotionDisc returns the maximum radius needed for Conservative Advancement to handle time-of-impact with rotations. */ - public native @Cast("btScalar") float getAngularMotionDisc(); - - public native @Cast("btScalar") float getContactBreakingThreshold(@Cast("btScalar") float defaultContactThresholdFactor); - - /**calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep) - * result is conservative */ - public native void calculateTemporalAabb(@Const @ByRef btTransform curTrans, @Const @ByRef btVector3 linvel, @Const @ByRef btVector3 angvel, @Cast("btScalar") float timeStep, @ByRef btVector3 temporalAabbMin, @ByRef btVector3 temporalAabbMax); - - public native @Cast("bool") boolean isPolyhedral(); - - public native @Cast("bool") boolean isConvex2d(); - - public native @Cast("bool") boolean isConvex(); - public native @Cast("bool") boolean isNonMoving(); - public native @Cast("bool") boolean isConcave(); - public native @Cast("bool") boolean isCompound(); - - public native @Cast("bool") boolean isSoftBody(); - - /**isInfinite is used to catch simulation error (aabb check) */ - public native @Cast("bool") boolean isInfinite(); - -// #ifndef __SPU__ - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - public native @Const @ByRef btVector3 getLocalScaling(); - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - //debugging support - public native @Cast("const char*") BytePointer getName(); -// #endif //__SPU__ - - public native int getShapeType(); - - /**the getAnisotropicRollingFrictionDirection can be used in combination with setAnisotropicFriction - * See Bullet/Demos/RollingFrictionDemo for an example */ - public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); - public native void setMargin(@Cast("btScalar") float margin); - public native @Cast("btScalar") float getMargin(); - - /**optional user data pointer */ - public native void setUserPointer(Pointer userPtr); - - public native Pointer getUserPointer(); - public native void setUserIndex(int index); - - public native int getUserIndex(); - - public native void setUserIndex2(int index); - - public native int getUserIndex2(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); - - public native void serializeSingleShape(btSerializer serializer); -} - -// clang-format off -// parser needs * with the name -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btCollisionShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCollisionShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCollisionShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCollisionShapeData position(long position) { - return (btCollisionShapeData)super.position(position); - } - @Override public btCollisionShapeData getPointer(long i) { - return new btCollisionShapeData((Pointer)this).offsetAddress(i); - } - - public native @Cast("char*") BytePointer m_name(); public native btCollisionShapeData m_name(BytePointer setter); - public native int m_shapeType(); public native btCollisionShapeData m_shapeType(int setter); - public native @Cast("char") byte m_padding(int i); public native btCollisionShapeData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} -// clang-format on - - -// #endif //BT_COLLISION_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H -// #define BT_POLYHEDRAL_CONVEX_SHAPE_H - -// #include "LinearMath/btMatrix3x3.h" -// #include "btConvexInternalShape.h" -@Opaque public static class btConvexPolyhedron extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btConvexPolyhedron() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexPolyhedron(Pointer p) { super(p); } -} - -/**The btPolyhedralConvexShape is an internal interface class for polyhedral convex shapes. */ -@NoOffset public static class btPolyhedralConvexShape extends btConvexInternalShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPolyhedralConvexShape(Pointer p) { super(p); } - - - /**optional method mainly used to generate multiple contact points by clipping polyhedral features (faces/edges) - * experimental/work-in-progress */ - public native @Cast("bool") boolean initializePolyhedralFeatures(int shiftVerticesByMargin/*=0*/); - public native @Cast("bool") boolean initializePolyhedralFeatures(); - - public native void setPolyhedralFeatures(@ByRef btConvexPolyhedron polyhedron); - - public native @Const btConvexPolyhedron getConvexPolyhedron(); - - //brute force implementations - - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native int getNumVertices(); - public native int getNumEdges(); - public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); - public native void getVertex(int i, @ByRef btVector3 vtx); - public native int getNumPlanes(); - public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); - // virtual int getIndex(int i) const = 0 ; - - public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); -} - -/**The btPolyhedralConvexAabbCachingShape adds aabb caching to the btPolyhedralConvexShape */ -@NoOffset public static class btPolyhedralConvexAabbCachingShape extends btPolyhedralConvexShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPolyhedralConvexAabbCachingShape(Pointer p) { super(p); } - - public native void getNonvirtualAabb(@Const @ByRef btTransform trans, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax, @Cast("btScalar") float margin); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void recalcLocalAabb(); -} - -// #endif //BT_POLYHEDRAL_CONVEX_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btConvexInternalShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CONVEX_INTERNAL_SHAPE_H -// #define BT_CONVEX_INTERNAL_SHAPE_H - -// #include "btConvexShape.h" -// #include "LinearMath/btAabbUtil2.h" - -/**The btConvexInternalShape is an internal base class, shared by most convex shape implementations. - * The btConvexInternalShape uses a default collision margin set to CONVEX_DISTANCE_MARGIN. - * This collision margin used by Gjk and some other algorithms, see also btCollisionMargin.h - * Note that when creating small shapes (derived from btConvexInternalShape), - * you need to make sure to set a smaller collision margin, using the 'setMargin' API - * There is a automatic mechanism 'setSafeMargin' used by btBoxShape and btCylinderShape */ -@NoOffset public static class btConvexInternalShape extends btConvexShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexInternalShape(Pointer p) { super(p); } - - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - - public native @Const @ByRef btVector3 getImplicitShapeDimensions(); - - /**warning: use setImplicitShapeDimensions with care - * changing a collision shape while the body is in the world is not recommended, - * it is best to remove the body from the world, then make the change, and re-add it - * alternatively flush the contact points, see documentation for 'cleanProxyFromPairs' */ - public native void setImplicitShapeDimensions(@Const @ByRef btVector3 dimensions); - - public native void setSafeMargin(@Cast("btScalar") float minDimension, @Cast("btScalar") float defaultMarginMultiplier/*=0.1f*/); - public native void setSafeMargin(@Cast("btScalar") float minDimension); - public native void setSafeMargin(@Const @ByRef btVector3 halfExtents, @Cast("btScalar") float defaultMarginMultiplier/*=0.1f*/); - public native void setSafeMargin(@Const @ByRef btVector3 halfExtents); - - /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void getAabbSlow(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - public native @Const @ByRef btVector3 getLocalScaling(); - - public native @Const @ByRef btVector3 getLocalScalingNV(); - - public native void setMargin(@Cast("btScalar") float margin); - public native @Cast("btScalar") float getMargin(); - - public native @Cast("btScalar") float getMarginNV(); - - public native int getNumPreferredPenetrationDirections(); - - public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btConvexInternalShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btConvexInternalShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btConvexInternalShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexInternalShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btConvexInternalShapeData position(long position) { - return (btConvexInternalShapeData)super.position(position); - } - @Override public btConvexInternalShapeData getPointer(long i) { - return new btConvexInternalShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btConvexInternalShapeData m_collisionShapeData(btCollisionShapeData setter); - - public native @ByRef btVector3FloatData m_localScaling(); public native btConvexInternalShapeData m_localScaling(btVector3FloatData setter); - - public native @ByRef btVector3FloatData m_implicitShapeDimensions(); public native btConvexInternalShapeData m_implicitShapeDimensions(btVector3FloatData setter); - - public native float m_collisionMargin(); public native btConvexInternalShapeData m_collisionMargin(float setter); - - public native int m_padding(); public native btConvexInternalShapeData m_padding(int setter); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -/**btConvexInternalAabbCachingShape adds local aabb caching for convex shapes, to avoid expensive bounding box calculations */ -@NoOffset public static class btConvexInternalAabbCachingShape extends btConvexInternalShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexInternalAabbCachingShape(Pointer p) { super(p); } - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void recalcLocalAabb(); -} - -// #endif //BT_CONVEX_INTERNAL_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btBoxShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_OBB_BOX_MINKOWSKI_H -// #define BT_OBB_BOX_MINKOWSKI_H - -// #include "btPolyhedralConvexShape.h" -// #include "btCollisionMargin.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btMinMax.h" - -/**The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space. */ -public static class btBoxShape extends btPolyhedralConvexShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBoxShape(Pointer p) { super(p); } - - - public native @ByVal btVector3 getHalfExtentsWithMargin(); - - public native @Const @ByRef btVector3 getHalfExtentsWithoutMargin(); - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public btBoxShape(@Const @ByRef btVector3 boxHalfExtents) { super((Pointer)null); allocate(boxHalfExtents); } - private native void allocate(@Const @ByRef btVector3 boxHalfExtents); - - public native void setMargin(@Cast("btScalar") float collisionMargin); - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); - - public native int getNumPlanes(); - - public native int getNumVertices(); - - public native int getNumEdges(); - - public native void getVertex(int i, @ByRef btVector3 vtx); - - public native void getPlaneEquation(@ByRef btVector4 plane, int i); - - public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); - - public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native int getNumPreferredPenetrationDirections(); - - public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); -} - -// #endif //BT_OBB_BOX_MINKOWSKI_H - - -// Parsed from BulletCollision/CollisionShapes/btSphereShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ -// #ifndef BT_SPHERE_MINKOWSKI_H -// #define BT_SPHERE_MINKOWSKI_H - -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types - -/**The btSphereShape implements an implicit sphere, centered around a local origin with radius. */ -public static class btSphereShape extends btConvexInternalShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSphereShape(Pointer p) { super(p); } - - - public btSphereShape(@Cast("btScalar") float radius) { super((Pointer)null); allocate(radius); } - private native void allocate(@Cast("btScalar") float radius); - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - //notice that the vectors should be unit length - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native @Cast("btScalar") float getRadius(); - - public native void setUnscaledRadius(@Cast("btScalar") float radius); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native void setMargin(@Cast("btScalar") float margin); - public native @Cast("btScalar") float getMargin(); -} - -// #endif //BT_SPHERE_MINKOWSKI_H - - -// Parsed from BulletCollision/CollisionShapes/btCapsuleShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CAPSULE_SHAPE_H -// #define BT_CAPSULE_SHAPE_H - -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types - -/**The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned around the X axis and btCapsuleShapeZ around the Z axis. - * The total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. - * The btCapsuleShape is a convex hull of two spheres. The btMultiSphereShape is a more general collision shape that takes the convex hull of multiple sphere, so it can also represent a capsule when just using two spheres. */ -@NoOffset public static class btCapsuleShape extends btConvexInternalShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCapsuleShape(Pointer p) { super(p); } - - - public btCapsuleShape(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } - private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); - - /**CollisionShape Interface */ - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - /** btConvexShape Interface */ - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public native void setMargin(@Cast("btScalar") float collisionMargin); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native @Cast("const char*") BytePointer getName(); - - public native int getUpAxis(); - - public native @Cast("btScalar") float getRadius(); - - public native @Cast("btScalar") float getHalfHeight(); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); - - public native void deSerializeFloat(btCapsuleShapeData dataBuffer); -} - -/**btCapsuleShapeX represents a capsule around the Z axis - * the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. */ -public static class btCapsuleShapeX extends btCapsuleShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCapsuleShapeX(Pointer p) { super(p); } - - public btCapsuleShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } - private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); - - //debugging - public native @Cast("const char*") BytePointer getName(); -} - -/**btCapsuleShapeZ represents a capsule around the Z axis - * the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. */ -public static class btCapsuleShapeZ extends btCapsuleShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCapsuleShapeZ(Pointer p) { super(p); } - - public btCapsuleShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } - private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); - - //debugging - public native @Cast("const char*") BytePointer getName(); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btCapsuleShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCapsuleShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCapsuleShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCapsuleShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCapsuleShapeData position(long position) { - return (btCapsuleShapeData)super.position(position); - } - @Override public btCapsuleShapeData getPointer(long i) { - return new btCapsuleShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btCapsuleShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); - - public native int m_upAxis(); public native btCapsuleShapeData m_upAxis(int setter); - - public native @Cast("char") byte m_padding(int i); public native btCapsuleShapeData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - - - -// #endif //BT_CAPSULE_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btCylinderShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CYLINDER_MINKOWSKI_H -// #define BT_CYLINDER_MINKOWSKI_H - -// #include "btBoxShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "LinearMath/btVector3.h" - -/** The btCylinderShape class implements a cylinder shape primitive, centered around the origin. Its central axis aligned with the Y axis. btCylinderShapeX is aligned with the X axis and btCylinderShapeZ around the Z axis. */ -@NoOffset public static class btCylinderShape extends btConvexInternalShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCylinderShape(Pointer p) { super(p); } - - - public native @ByVal btVector3 getHalfExtentsWithMargin(); - - public native @Const @ByRef btVector3 getHalfExtentsWithoutMargin(); - - public btCylinderShape(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } - private native void allocate(@Const @ByRef btVector3 halfExtents); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public native void setMargin(@Cast("btScalar") float collisionMargin); - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - - //use box inertia - // virtual void calculateLocalInertia(btScalar mass,btVector3& inertia) const; - - public native int getUpAxis(); - - public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); - - public native @Cast("btScalar") float getRadius(); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -public static class btCylinderShapeX extends btCylinderShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCylinderShapeX(Pointer p) { super(p); } - - - public btCylinderShapeX(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } - private native void allocate(@Const @ByRef btVector3 halfExtents); - - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native @Cast("btScalar") float getRadius(); -} - -public static class btCylinderShapeZ extends btCylinderShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCylinderShapeZ(Pointer p) { super(p); } - - - public btCylinderShapeZ(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } - private native void allocate(@Const @ByRef btVector3 halfExtents); - - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native @Cast("btScalar") float getRadius(); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btCylinderShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCylinderShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCylinderShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCylinderShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCylinderShapeData position(long position) { - return (btCylinderShapeData)super.position(position); - } - @Override public btCylinderShapeData getPointer(long i) { - return new btCylinderShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btCylinderShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); - - public native int m_upAxis(); public native btCylinderShapeData m_upAxis(int setter); - - public native @Cast("char") byte m_padding(int i); public native btCylinderShapeData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_CYLINDER_MINKOWSKI_H - - -// Parsed from BulletCollision/CollisionShapes/btConeShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CONE_MINKOWSKI_H -// #define BT_CONE_MINKOWSKI_H - -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types - -/**The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y axis. The btConeShapeX is aligned around the X axis and btConeShapeZ around the Z axis. */ -@NoOffset public static class btConeShape extends btConvexInternalShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConeShape(Pointer p) { super(p); } - - - public btConeShape(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } - private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public native @Cast("btScalar") float getRadius(); - public native @Cast("btScalar") float getHeight(); - - public native void setRadius(@Cast("const btScalar") float radius); - public native void setHeight(@Cast("const btScalar") float height); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native @Cast("const char*") BytePointer getName(); - - /**choose upAxis index */ - public native void setConeUpIndex(int upIndex); - - public native int getConeUpIndex(); - - public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -/**btConeShape implements a Cone shape, around the X axis */ -public static class btConeShapeX extends btConeShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConeShapeX(Pointer p) { super(p); } - - public btConeShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } - private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); - - public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); - - //debugging - public native @Cast("const char*") BytePointer getName(); -} - -/**btConeShapeZ implements a Cone shape, around the Z axis */ -public static class btConeShapeZ extends btConeShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConeShapeZ(Pointer p) { super(p); } - - public btConeShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } - private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); - - public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); - - //debugging - public native @Cast("const char*") BytePointer getName(); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btConeShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btConeShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btConeShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConeShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btConeShapeData position(long position) { - return (btConeShapeData)super.position(position); - } - @Override public btConeShapeData getPointer(long i) { - return new btConeShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btConeShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); - - public native int m_upIndex(); public native btConeShapeData m_upIndex(int setter); - - public native @Cast("char") byte m_padding(int i); public native btConeShapeData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_CONE_MINKOWSKI_H - - -// Parsed from BulletCollision/CollisionShapes/btConcaveShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CONCAVE_SHAPE_H -// #define BT_CONCAVE_SHAPE_H - -// #include "btCollisionShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "btTriangleCallback.h" - -/** PHY_ScalarType enumerates possible scalar types. - * See the btStridingMeshInterface or btHeightfieldTerrainShape for its use */ -/** enum PHY_ScalarType */ -public static final int - PHY_FLOAT = 0, - PHY_DOUBLE = 1, - PHY_INTEGER = 2, - PHY_SHORT = 3, - PHY_FIXEDPOINT88 = 4, - PHY_UCHAR = 5; - -/**The btConcaveShape class provides an interface for non-moving (static) concave shapes. - * It has been implemented by the btStaticPlaneShape, btBvhTriangleMeshShape and btHeightfieldTerrainShape. */ -@NoOffset public static class btConcaveShape extends btCollisionShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConcaveShape(Pointer p) { super(p); } - - - public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - public native @Cast("btScalar") float getMargin(); - public native void setMargin(@Cast("btScalar") float collisionMargin); -} - -// #endif //BT_CONCAVE_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btTriangleCallback.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_TRIANGLE_CALLBACK_H -// #define BT_TRIANGLE_CALLBACK_H - -// #include "LinearMath/btVector3.h" - -/**The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTriangles. - * This callback is called by processAllTriangles for all btConcaveShape derived class, such as btBvhTriangleMeshShape, btStaticPlaneShape and btHeightfieldTerrainShape. */ -public static class btTriangleCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleCallback(Pointer p) { super(p); } - - public native void processTriangle(btVector3 triangle, int partId, int triangleIndex); -} - -public static class btInternalTriangleIndexCallback extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btInternalTriangleIndexCallback(Pointer p) { super(p); } - - public native void internalProcessTriangleIndex(btVector3 triangle, int partId, int triangleIndex); -} - -// #endif //BT_TRIANGLE_CALLBACK_H - - -// Parsed from BulletCollision/CollisionShapes/btStaticPlaneShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_STATIC_PLANE_SHAPE_H -// #define BT_STATIC_PLANE_SHAPE_H - -// #include "btConcaveShape.h" - -/**The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. */ -@NoOffset public static class btStaticPlaneShape extends btConcaveShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btStaticPlaneShape(Pointer p) { super(p); } - - - public btStaticPlaneShape(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConstant) { super((Pointer)null); allocate(planeNormal, planeConstant); } - private native void allocate(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConstant); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - public native @Const @ByRef btVector3 getLocalScaling(); - - public native @Const @ByRef btVector3 getPlaneNormal(); - - public native @Cast("const btScalar") float getPlaneConstant(); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btStaticPlaneShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btStaticPlaneShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btStaticPlaneShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btStaticPlaneShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btStaticPlaneShapeData position(long position) { - return (btStaticPlaneShapeData)super.position(position); - } - @Override public btStaticPlaneShapeData getPointer(long i) { - return new btStaticPlaneShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btStaticPlaneShapeData m_collisionShapeData(btCollisionShapeData setter); - - public native @ByRef btVector3FloatData m_localScaling(); public native btStaticPlaneShapeData m_localScaling(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_planeNormal(); public native btStaticPlaneShapeData m_planeNormal(btVector3FloatData setter); - public native float m_planeConstant(); public native btStaticPlaneShapeData m_planeConstant(float setter); - public native @Cast("char") byte m_pad(int i); public native btStaticPlaneShapeData m_pad(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_pad(); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_STATIC_PLANE_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btConvexHullShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CONVEX_HULL_SHAPE_H -// #define BT_CONVEX_HULL_SHAPE_H - -// #include "btPolyhedralConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "LinearMath/btAlignedObjectArray.h" - -/**The btConvexHullShape implements an implicit convex hull of an array of vertices. - * Bullet provides a general and fast collision detector for convex shapes based on GJK and EPA using localGetSupportingVertex. */ -@NoOffset public static class btConvexHullShape extends btPolyhedralConvexAabbCachingShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexHullShape(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btConvexHullShape(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btConvexHullShape position(long position) { - return (btConvexHullShape)super.position(position); - } - @Override public btConvexHullShape getPointer(long i) { - return new btConvexHullShape((Pointer)this).offsetAddress(i); - } - - - /**this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive btScalar (x,y,z), the striding defines the number of bytes between each point, in memory. - * It is easier to not pass any points in the constructor, and just add one point at a time, using addPoint. - * btConvexHullShape make an internal copy of the points. */ - public btConvexHullShape(@Cast("const btScalar*") FloatPointer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } - private native void allocate(@Cast("const btScalar*") FloatPointer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); - public btConvexHullShape() { super((Pointer)null); allocate(); } - private native void allocate(); - public btConvexHullShape(@Cast("const btScalar*") FloatBuffer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } - private native void allocate(@Cast("const btScalar*") FloatBuffer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); - public btConvexHullShape(@Cast("const btScalar*") float[] points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } - private native void allocate(@Cast("const btScalar*") float[] points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); - - public native void addPoint(@Const @ByRef btVector3 point, @Cast("bool") boolean recalculateLocalAabb/*=true*/); - public native void addPoint(@Const @ByRef btVector3 point); - - public native btVector3 getUnscaledPoints(); - - /**getPoints is obsolete, please use getUnscaledPoints */ - public native @Const btVector3 getPoints(); - - public native void optimizeConvexHull(); - - public native @ByVal btVector3 getScaledPoint(int i); - - public native int getNumPoints(); - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatPointer minProj, @Cast("btScalar*") @ByRef FloatPointer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); - public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatBuffer minProj, @Cast("btScalar*") @ByRef FloatBuffer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); - public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef float[] minProj, @Cast("btScalar*") @ByRef float[] maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native int getNumVertices(); - public native int getNumEdges(); - public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); - public native void getVertex(int i, @ByRef btVector3 vtx); - public native int getNumPlanes(); - public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); - public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); - - /**in case we receive negative scaling */ - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -// clang-format off - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btConvexHullShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btConvexHullShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btConvexHullShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexHullShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btConvexHullShapeData position(long position) { - return (btConvexHullShapeData)super.position(position); - } - @Override public btConvexHullShapeData getPointer(long i) { - return new btConvexHullShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btConvexHullShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); - - public native btVector3FloatData m_unscaledPointsFloatPtr(); public native btConvexHullShapeData m_unscaledPointsFloatPtr(btVector3FloatData setter); - public native btVector3DoubleData m_unscaledPointsDoublePtr(); public native btConvexHullShapeData m_unscaledPointsDoublePtr(btVector3DoubleData setter); - - public native int m_numUnscaledPoints(); public native btConvexHullShapeData m_numUnscaledPoints(int setter); - public native @Cast("char") byte m_padding3(int i); public native btConvexHullShapeData m_padding3(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding3(); - -} - -// clang-format on - - - -// #endif //BT_CONVEX_HULL_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btStridingMeshInterface.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_STRIDING_MESHINTERFACE_H -// #define BT_STRIDING_MESHINTERFACE_H - -// #include "LinearMath/btVector3.h" -// #include "btTriangleCallback.h" -// #include "btConcaveShape.h" - -/** The btStridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with btBvhTriangleMeshShape and some other collision shapes. - * Using index striding of 3*sizeof(integer) it can use triangle arrays, using index striding of 1*sizeof(integer) it can handle triangle strips. - * It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory. */ -@NoOffset public static class btStridingMeshInterface extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btStridingMeshInterface(Pointer p) { super(p); } - - - public native void InternalProcessAllTriangles(btInternalTriangleIndexCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - /**brute force method to calculate aabb */ - public native void calculateAabbBruteForce(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - /** get read and write access to a subpart of a triangle mesh - * this subpart has a continuous array of vertices and indices - * in this way the mesh can be handled as chunks of memory with striding - * very similar to OpenGL vertexarray support - * make a call to unLockVertexBase when the read and write access is finished */ - public native void getLockedVertexIndexBase(@Cast("unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); - - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); - - /** unLockVertexBase finishes the access to a subpart of the triangle mesh - * make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished */ - public native void unLockVertexBase(int subpart); - - public native void unLockReadOnlyVertexBase(int subpart); - - /** getNumSubParts returns the number of separate subparts - * each subpart has a continuous array of vertices and indices */ - public native int getNumSubParts(); - - public native void preallocateVertices(int numverts); - public native void preallocateIndices(int numindices); - - public native @Cast("bool") boolean hasPremadeAabb(); - public native void setPremadeAabb(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - public native void getPremadeAabb(btVector3 aabbMin, btVector3 aabbMax); - - public native @Const @ByRef btVector3 getScaling(); - public native void setScaling(@Const @ByRef btVector3 scaling); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -public static class btIntIndexData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btIntIndexData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btIntIndexData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btIntIndexData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btIntIndexData position(long position) { - return (btIntIndexData)super.position(position); - } - @Override public btIntIndexData getPointer(long i) { - return new btIntIndexData((Pointer)this).offsetAddress(i); - } - - public native int m_value(); public native btIntIndexData m_value(int setter); -} - -public static class btShortIntIndexData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btShortIntIndexData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btShortIntIndexData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btShortIntIndexData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btShortIntIndexData position(long position) { - return (btShortIntIndexData)super.position(position); - } - @Override public btShortIntIndexData getPointer(long i) { - return new btShortIntIndexData((Pointer)this).offsetAddress(i); - } - - public native short m_value(); public native btShortIntIndexData m_value(short setter); - public native @Cast("char") byte m_pad(int i); public native btShortIntIndexData m_pad(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_pad(); -} - -public static class btShortIntIndexTripletData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btShortIntIndexTripletData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btShortIntIndexTripletData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btShortIntIndexTripletData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btShortIntIndexTripletData position(long position) { - return (btShortIntIndexTripletData)super.position(position); - } - @Override public btShortIntIndexTripletData getPointer(long i) { - return new btShortIntIndexTripletData((Pointer)this).offsetAddress(i); - } - - public native short m_values(int i); public native btShortIntIndexTripletData m_values(int i, short setter); - @MemberGetter public native ShortPointer m_values(); - public native @Cast("char") byte m_pad(int i); public native btShortIntIndexTripletData m_pad(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_pad(); -} - -public static class btCharIndexTripletData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCharIndexTripletData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCharIndexTripletData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCharIndexTripletData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCharIndexTripletData position(long position) { - return (btCharIndexTripletData)super.position(position); - } - @Override public btCharIndexTripletData getPointer(long i) { - return new btCharIndexTripletData((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned char") byte m_values(int i); public native btCharIndexTripletData m_values(int i, byte setter); - @MemberGetter public native @Cast("unsigned char*") BytePointer m_values(); - public native @Cast("char") byte m_pad(); public native btCharIndexTripletData m_pad(byte setter); -} - -// clang-format off - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btMeshPartData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btMeshPartData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btMeshPartData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btMeshPartData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btMeshPartData position(long position) { - return (btMeshPartData)super.position(position); - } - @Override public btMeshPartData getPointer(long i) { - return new btMeshPartData((Pointer)this).offsetAddress(i); - } - - public native btVector3FloatData m_vertices3f(); public native btMeshPartData m_vertices3f(btVector3FloatData setter); - public native btVector3DoubleData m_vertices3d(); public native btMeshPartData m_vertices3d(btVector3DoubleData setter); - - public native btIntIndexData m_indices32(); public native btMeshPartData m_indices32(btIntIndexData setter); - public native btShortIntIndexTripletData m_3indices16(); public native btMeshPartData m_3indices16(btShortIntIndexTripletData setter); - public native btCharIndexTripletData m_3indices8(); public native btMeshPartData m_3indices8(btCharIndexTripletData setter); - - public native btShortIntIndexData m_indices16(); public native btMeshPartData m_indices16(btShortIntIndexData setter);//backwards compatibility - - public native int m_numTriangles(); public native btMeshPartData m_numTriangles(int setter);//length of m_indices = m_numTriangles - public native int m_numVertices(); public native btMeshPartData m_numVertices(int setter); -} - - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btStridingMeshInterfaceData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btStridingMeshInterfaceData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btStridingMeshInterfaceData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btStridingMeshInterfaceData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btStridingMeshInterfaceData position(long position) { - return (btStridingMeshInterfaceData)super.position(position); - } - @Override public btStridingMeshInterfaceData getPointer(long i) { - return new btStridingMeshInterfaceData((Pointer)this).offsetAddress(i); - } - - public native btMeshPartData m_meshPartsPtr(); public native btStridingMeshInterfaceData m_meshPartsPtr(btMeshPartData setter); - public native @ByRef btVector3FloatData m_scaling(); public native btStridingMeshInterfaceData m_scaling(btVector3FloatData setter); - public native int m_numMeshParts(); public native btStridingMeshInterfaceData m_numMeshParts(int setter); - public native @Cast("char") byte m_padding(int i); public native btStridingMeshInterfaceData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - -// clang-format on - - - -// #endif //BT_STRIDING_MESHINTERFACE_H - - -// Parsed from BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H -// #define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H - -// #include "btStridingMeshInterface.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btScalar.h" - -/**The btIndexedMesh indexes a single vertex and index array. Multiple btIndexedMesh objects can be passed into a btTriangleIndexVertexArray using addIndexedMesh. - * Instead of the number of indices, we pass the number of triangles. */ -@NoOffset public static class btIndexedMesh extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btIndexedMesh(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btIndexedMesh(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btIndexedMesh position(long position) { - return (btIndexedMesh)super.position(position); - } - @Override public btIndexedMesh getPointer(long i) { - return new btIndexedMesh((Pointer)this).offsetAddress(i); - } - - - public native int m_numTriangles(); public native btIndexedMesh m_numTriangles(int setter); - public native @Cast("const unsigned char*") BytePointer m_triangleIndexBase(); public native btIndexedMesh m_triangleIndexBase(BytePointer setter); - // Size in byte of the indices for one triangle (3*sizeof(index_type) if the indices are tightly packed) - public native int m_triangleIndexStride(); public native btIndexedMesh m_triangleIndexStride(int setter); - public native int m_numVertices(); public native btIndexedMesh m_numVertices(int setter); - public native @Cast("const unsigned char*") BytePointer m_vertexBase(); public native btIndexedMesh m_vertexBase(BytePointer setter); - // Size of a vertex, in bytes - public native int m_vertexStride(); public native btIndexedMesh m_vertexStride(int setter); - - // The index type is set when adding an indexed mesh to the - // btTriangleIndexVertexArray, do not set it manually - public native @Cast("PHY_ScalarType") int m_indexType(); public native btIndexedMesh m_indexType(int setter); - - // The vertex type has a default type similar to Bullet's precision mode (float or double) - // but can be set manually if you for example run Bullet with double precision but have - // mesh data in single precision.. - public native @Cast("PHY_ScalarType") int m_vertexType(); public native btIndexedMesh m_vertexType(int setter); - - public btIndexedMesh() { super((Pointer)null); allocate(); } - private native void allocate(); -} - -/**The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays. - * Additional meshes can be added using addIndexedMesh - * No duplicate is made of the vertex/index data, it only indexes into external vertex/index arrays. - * So keep those arrays around during the lifetime of this btTriangleIndexVertexArray. */ -@NoOffset public static class btTriangleIndexVertexArray extends btStridingMeshInterface { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleIndexVertexArray(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTriangleIndexVertexArray(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btTriangleIndexVertexArray position(long position) { - return (btTriangleIndexVertexArray)super.position(position); - } - @Override public btTriangleIndexVertexArray getPointer(long i) { - return new btTriangleIndexVertexArray((Pointer)this).offsetAddress(i); - } - - - public btTriangleIndexVertexArray() { super((Pointer)null); allocate(); } - private native void allocate(); - - //just to be backwards compatible - public btTriangleIndexVertexArray(int numTriangles, IntPointer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatPointer vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } - private native void allocate(int numTriangles, IntPointer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatPointer vertexBase, int vertexStride); - public btTriangleIndexVertexArray(int numTriangles, IntBuffer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatBuffer vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } - private native void allocate(int numTriangles, IntBuffer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatBuffer vertexBase, int vertexStride); - public btTriangleIndexVertexArray(int numTriangles, int[] triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") float[] vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } - private native void allocate(int numTriangles, int[] triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") float[] vertexBase, int vertexStride); - - public native void addIndexedMesh(@Const @ByRef btIndexedMesh mesh, @Cast("PHY_ScalarType") int indexType/*=PHY_INTEGER*/); - public native void addIndexedMesh(@Const @ByRef btIndexedMesh mesh); - - public native void getLockedVertexIndexBase(@Cast("unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); - public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); - - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); - public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); - - /** unLockVertexBase finishes the access to a subpart of the triangle mesh - * make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished */ - public native void unLockVertexBase(int subpart); - - public native void unLockReadOnlyVertexBase(int subpart); - - /** getNumSubParts returns the number of separate subparts - * each subpart has a continuous array of vertices and indices */ - public native int getNumSubParts(); - - public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btVector3 getIndexedMeshArray(); - - public native void preallocateVertices(int numverts); - public native void preallocateIndices(int numindices); - - public native @Cast("bool") boolean hasPremadeAabb(); - public native void setPremadeAabb(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - public native void getPremadeAabb(btVector3 aabbMin, btVector3 aabbMax); -} - -// #endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H - - -// Parsed from BulletCollision/CollisionShapes/btTriangleMesh.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_TRIANGLE_MESH_H -// #define BT_TRIANGLE_MESH_H - -// #include "btTriangleIndexVertexArray.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btAlignedObjectArray.h" - -/**The btTriangleMesh class is a convenience class derived from btTriangleIndexVertexArray, that provides storage for a concave triangle mesh. It can be used as data for the btBvhTriangleMeshShape. - * It allows either 32bit or 16bit indices, and 4 (x-y-z-w) or 3 (x-y-z) component vertices. - * If you want to share triangle/index data between graphics mesh and collision mesh (btBvhTriangleMeshShape), you can directly use btTriangleIndexVertexArray or derive your own class from btStridingMeshInterface. - * Performance of btTriangleMesh and btTriangleIndexVertexArray used in a btBvhTriangleMeshShape is the same. */ -@NoOffset public static class btTriangleMesh extends btTriangleIndexVertexArray { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleMesh(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTriangleMesh(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btTriangleMesh position(long position) { - return (btTriangleMesh)super.position(position); - } - @Override public btTriangleMesh getPointer(long i) { - return new btTriangleMesh((Pointer)this).offsetAddress(i); - } - - public native @Cast("btScalar") float m_weldingThreshold(); public native btTriangleMesh m_weldingThreshold(float setter); - - public btTriangleMesh(@Cast("bool") boolean use32bitIndices/*=true*/, @Cast("bool") boolean use4componentVertices/*=true*/) { super((Pointer)null); allocate(use32bitIndices, use4componentVertices); } - private native void allocate(@Cast("bool") boolean use32bitIndices/*=true*/, @Cast("bool") boolean use4componentVertices/*=true*/); - public btTriangleMesh() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native @Cast("bool") boolean getUse32bitIndices(); - - public native @Cast("bool") boolean getUse4componentVertices(); - /**By default addTriangle won't search for duplicate vertices, because the search is very slow for large triangle meshes. - * In general it is better to directly use btTriangleIndexVertexArray instead. */ - public native void addTriangle(@Const @ByRef btVector3 vertex0, @Const @ByRef btVector3 vertex1, @Const @ByRef btVector3 vertex2, @Cast("bool") boolean removeDuplicateVertices/*=false*/); - public native void addTriangle(@Const @ByRef btVector3 vertex0, @Const @ByRef btVector3 vertex1, @Const @ByRef btVector3 vertex2); - - /**Add a triangle using its indices. Make sure the indices are pointing within the vertices array, so add the vertices first (and to be sure, avoid removal of duplicate vertices) */ - public native void addTriangleIndices(int index1, int index2, int index3); - - public native int getNumTriangles(); - - public native void preallocateVertices(int numverts); - public native void preallocateIndices(int numindices); - - /**findOrAddVertex is an internal method, use addTriangle instead */ - public native int findOrAddVertex(@Const @ByRef btVector3 vertex, @Cast("bool") boolean removeDuplicateVertices); - /**addIndex is an internal method, use addTriangle instead */ - public native void addIndex(int index); -} - -// #endif //BT_TRIANGLE_MESH_H - - -// Parsed from BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ -// #ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H -// #define BT_CONVEX_TRIANGLEMESH_SHAPE_H - -// #include "btPolyhedralConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types - -/** The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as btConvexHullShape. - * A small benefit of this class is that it uses the btStridingMeshInterface, so you can avoid the duplication of the triangle mesh data. Nevertheless, most users should use the much better performing btConvexHullShape instead. */ -@NoOffset public static class btConvexTriangleMeshShape extends btPolyhedralConvexAabbCachingShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConvexTriangleMeshShape(Pointer p) { super(p); } - - - public btConvexTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean calcAabb/*=true*/) { super((Pointer)null); allocate(meshInterface, calcAabb); } - private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean calcAabb/*=true*/); - public btConvexTriangleMeshShape(btStridingMeshInterface meshInterface) { super((Pointer)null); allocate(meshInterface); } - private native void allocate(btStridingMeshInterface meshInterface); - - public native btStridingMeshInterface getMeshInterface(); - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native int getNumVertices(); - public native int getNumEdges(); - public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); - public native void getVertex(int i, @ByRef btVector3 vtx); - public native int getNumPlanes(); - public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); - public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - public native @Const @ByRef btVector3 getLocalScaling(); - - /**computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia - * and the center of mass to the current coordinate system. A mass of 1 is assumed, for other masses just multiply the computed "inertia" - * by the mass. The resulting transform "principal" has to be applied inversely to the mesh in order for the local coordinate system of the - * shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform - * of the collision object by the principal transform. This method also computes the volume of the convex mesh. */ - public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef FloatPointer volume); - public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef FloatBuffer volume); - public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef float[] volume); -} - -// #endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btTriangleMeshShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_TRIANGLE_MESH_SHAPE_H -// #define BT_TRIANGLE_MESH_SHAPE_H - -// #include "btConcaveShape.h" -// #include "btStridingMeshInterface.h" - -/**The btTriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly, use btBvhTriangleMeshShape instead. */ -@NoOffset public static class btTriangleMeshShape extends btConcaveShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleMeshShape(Pointer p) { super(p); } - - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - - public native void recalcLocalAabb(); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - public native @Const @ByRef btVector3 getLocalScaling(); - - public native btStridingMeshInterface getMeshInterface(); - - public native @Const @ByRef btVector3 getLocalAabbMin(); - public native @Const @ByRef btVector3 getLocalAabbMax(); - - //debugging - public native @Cast("const char*") BytePointer getName(); -} - -// #endif //BT_TRIANGLE_MESH_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btOptimizedBvh.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -/**Contains contributions from Disney Studio's */ - -// #ifndef BT_OPTIMIZED_BVH_H -// #define BT_OPTIMIZED_BVH_H - -// #include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" - -/**The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes, through the btStridingMeshInterface. */ -public static class btOptimizedBvh extends btQuantizedBvh { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btOptimizedBvh(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btOptimizedBvh(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btOptimizedBvh position(long position) { - return (btOptimizedBvh)super.position(position); - } - @Override public btOptimizedBvh getPointer(long i) { - return new btOptimizedBvh((Pointer)this).offsetAddress(i); - } - - public btOptimizedBvh() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native void build(btStridingMeshInterface triangles, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); - - public native void refit(btStridingMeshInterface triangles, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - public native void refitPartial(btStridingMeshInterface triangles, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - public native void updateBvhNodes(btStridingMeshInterface meshInterface, int firstNode, int endNode, int index); - - /** Data buffer MUST be 16 byte aligned */ - public native @Cast("bool") boolean serializeInPlace(Pointer o_alignedDataBuffer, @Cast("unsigned") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); - - /**deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' */ - public static native btOptimizedBvh deSerializeInPlace(Pointer i_alignedDataBuffer, @Cast("unsigned int") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); -} - -// #endif //BT_OPTIMIZED_BVH_H - - -// Parsed from BulletCollision/CollisionShapes/btTriangleInfoMap.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2010 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef _BT_TRIANGLE_INFO_MAP_H -// #define _BT_TRIANGLE_INFO_MAP_H - -// #include "LinearMath/btHashMap.h" -// #include "LinearMath/btSerializer.h" - -/**for btTriangleInfo m_flags */ -public static final int TRI_INFO_V0V1_CONVEX = 1; -public static final int TRI_INFO_V1V2_CONVEX = 2; -public static final int TRI_INFO_V2V0_CONVEX = 4; - -public static final int TRI_INFO_V0V1_SWAP_NORMALB = 8; -public static final int TRI_INFO_V1V2_SWAP_NORMALB = 16; -public static final int TRI_INFO_V2V0_SWAP_NORMALB = 32; - -/**The btTriangleInfo structure stores information to adjust collision normals to avoid collisions against internal edges - * it can be generated using */ -@NoOffset public static class btTriangleInfo extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleInfo(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTriangleInfo(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btTriangleInfo position(long position) { - return (btTriangleInfo)super.position(position); - } - @Override public btTriangleInfo getPointer(long i) { - return new btTriangleInfo((Pointer)this).offsetAddress(i); - } - - public btTriangleInfo() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native int m_flags(); public native btTriangleInfo m_flags(int setter); - - public native @Cast("btScalar") float m_edgeV0V1Angle(); public native btTriangleInfo m_edgeV0V1Angle(float setter); - public native @Cast("btScalar") float m_edgeV1V2Angle(); public native btTriangleInfo m_edgeV1V2Angle(float setter); - public native @Cast("btScalar") float m_edgeV2V0Angle(); public native btTriangleInfo m_edgeV2V0Angle(float setter); -} - -/**The btTriangleInfoMap stores edge angle information for some triangles. You can compute this information yourself or using btGenerateInternalEdgeInfo. */ -@NoOffset public static class btTriangleInfoMap extends btHashMap_btHashPtr_voidPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleInfoMap(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTriangleInfoMap(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btTriangleInfoMap position(long position) { - return (btTriangleInfoMap)super.position(position); - } - @Override public btTriangleInfoMap getPointer(long i) { - return new btTriangleInfoMap((Pointer)this).offsetAddress(i); - } - - public native @Cast("btScalar") float m_convexEpsilon(); public native btTriangleInfoMap m_convexEpsilon(float setter); /**used to determine if an edge or contact normal is convex, using the dot product */ - public native @Cast("btScalar") float m_planarEpsilon(); public native btTriangleInfoMap m_planarEpsilon(float setter); /**used to determine if a triangle edge is planar with zero angle */ - public native @Cast("btScalar") float m_equalVertexThreshold(); public native btTriangleInfoMap m_equalVertexThreshold(float setter); /**used to compute connectivity: if the distance between two vertices is smaller than m_equalVertexThreshold, they are considered to be 'shared' */ - public native @Cast("btScalar") float m_edgeDistanceThreshold(); public native btTriangleInfoMap m_edgeDistanceThreshold(float setter); /**used to determine edge contacts: if the closest distance between a contact point and an edge is smaller than this distance threshold it is considered to "hit the edge" */ - public native @Cast("btScalar") float m_maxEdgeAngleThreshold(); public native btTriangleInfoMap m_maxEdgeAngleThreshold(float setter); //ignore edges that connect triangles at an angle larger than this m_maxEdgeAngleThreshold - public native @Cast("btScalar") float m_zeroAreaThreshold(); public native btTriangleInfoMap m_zeroAreaThreshold(float setter); /**used to determine if a triangle is degenerate (length squared of cross product of 2 triangle edges < threshold) */ - - public btTriangleInfoMap() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); - - public native void deSerialize(@ByRef btTriangleInfoMapData data); -} - -// clang-format off - -/**those fields have to be float and not btScalar for the serialization to work properly */ -public static class btTriangleInfoData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btTriangleInfoData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTriangleInfoData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleInfoData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btTriangleInfoData position(long position) { - return (btTriangleInfoData)super.position(position); - } - @Override public btTriangleInfoData getPointer(long i) { - return new btTriangleInfoData((Pointer)this).offsetAddress(i); - } - - public native int m_flags(); public native btTriangleInfoData m_flags(int setter); - public native float m_edgeV0V1Angle(); public native btTriangleInfoData m_edgeV0V1Angle(float setter); - public native float m_edgeV1V2Angle(); public native btTriangleInfoData m_edgeV1V2Angle(float setter); - public native float m_edgeV2V0Angle(); public native btTriangleInfoData m_edgeV2V0Angle(float setter); -} - -public static class btTriangleInfoMapData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btTriangleInfoMapData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTriangleInfoMapData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleInfoMapData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btTriangleInfoMapData position(long position) { - return (btTriangleInfoMapData)super.position(position); - } - @Override public btTriangleInfoMapData getPointer(long i) { - return new btTriangleInfoMapData((Pointer)this).offsetAddress(i); - } - - public native IntPointer m_hashTablePtr(); public native btTriangleInfoMapData m_hashTablePtr(IntPointer setter); - public native IntPointer m_nextPtr(); public native btTriangleInfoMapData m_nextPtr(IntPointer setter); - public native btTriangleInfoData m_valueArrayPtr(); public native btTriangleInfoMapData m_valueArrayPtr(btTriangleInfoData setter); - public native IntPointer m_keyArrayPtr(); public native btTriangleInfoMapData m_keyArrayPtr(IntPointer setter); - - public native float m_convexEpsilon(); public native btTriangleInfoMapData m_convexEpsilon(float setter); - public native float m_planarEpsilon(); public native btTriangleInfoMapData m_planarEpsilon(float setter); - public native float m_equalVertexThreshold(); public native btTriangleInfoMapData m_equalVertexThreshold(float setter); - public native float m_edgeDistanceThreshold(); public native btTriangleInfoMapData m_edgeDistanceThreshold(float setter); - public native float m_zeroAreaThreshold(); public native btTriangleInfoMapData m_zeroAreaThreshold(float setter); - - public native int m_nextSize(); public native btTriangleInfoMapData m_nextSize(int setter); - public native int m_hashTableSize(); public native btTriangleInfoMapData m_hashTableSize(int setter); - public native int m_numValues(); public native btTriangleInfoMapData m_numValues(int setter); - public native int m_numKeys(); public native btTriangleInfoMapData m_numKeys(int setter); - public native @Cast("char") byte m_padding(int i); public native btTriangleInfoMapData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - -// clang-format on - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //_BT_TRIANGLE_INFO_MAP_H - - -// Parsed from BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H -// #define BT_BVH_TRIANGLE_MESH_SHAPE_H - -// #include "btTriangleMeshShape.h" -// #include "btOptimizedBvh.h" -// #include "LinearMath/btAlignedAllocator.h" -// #include "btTriangleInfoMap.h" - -/**The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving objects. - * If you required moving concave triangle meshes, it is recommended to perform convex decomposition - * using HACD, see Bullet/Demos/ConvexDecompositionDemo. - * Alternatively, you can use btGimpactMeshShape for moving concave triangle meshes. - * btBvhTriangleMeshShape has several optimizations, such as bounding volume hierarchy and - * cache friendly traversal for PlayStation 3 Cell SPU. - * It is recommended to enable useQuantizedAabbCompression for better memory usage. - * It takes a triangle mesh as input, for example a btTriangleMesh or btTriangleIndexVertexArray. The btBvhTriangleMeshShape class allows for triangle mesh deformations by a refit or partialRefit method. - * Instead of building the bounding volume hierarchy acceleration structure, it is also possible to serialize (save) and deserialize (load) the structure from disk. - * See Demos\ConcaveDemo\ConcavePhysicsDemo.cpp for an example. */ -@NoOffset public static class btBvhTriangleMeshShape extends btTriangleMeshShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBvhTriangleMeshShape(Pointer p) { super(p); } - - - public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Cast("bool") boolean buildBvh/*=true*/) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, buildBvh); } - private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Cast("bool") boolean buildBvh/*=true*/); - public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression); } - private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression); - - /**optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb */ - public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("bool") boolean buildBvh/*=true*/) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax, buildBvh); } - private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("bool") boolean buildBvh/*=true*/); - public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax); } - private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); - - public native @Cast("bool") boolean getOwnsBvh(); - - public native void performRaycast(btTriangleCallback callback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget); - public native void performConvexcast(btTriangleCallback callback, @Const @ByRef btVector3 boxSource, @Const @ByRef btVector3 boxTarget, @Const @ByRef btVector3 boxMin, @Const @ByRef btVector3 boxMax); - - public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - public native void refitTree(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - /**for a fast incremental refit of parts of the tree. Note: the entire AABB of the tree will become more conservative, it never shrinks */ - public native void partialRefitTree(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - public native btOptimizedBvh getOptimizedBvh(); - - public native void setOptimizedBvh(btOptimizedBvh bvh, @Const @ByRef(nullValue = "btVector3(1, 1, 1)") btVector3 localScaling); - public native void setOptimizedBvh(btOptimizedBvh bvh); - - public native void buildOptimizedBvh(); - - public native @Cast("bool") boolean usesQuantizedAabbCompression(); - - public native void setTriangleInfoMap(btTriangleInfoMap triangleInfoMap); - - public native btTriangleInfoMap getTriangleInfoMap(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); - - public native void serializeSingleBvh(btSerializer serializer); - - public native void serializeSingleTriangleInfoMap(btSerializer serializer); -} - -// clang-format off - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btTriangleMeshShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btTriangleMeshShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTriangleMeshShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTriangleMeshShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btTriangleMeshShapeData position(long position) { - return (btTriangleMeshShapeData)super.position(position); - } - @Override public btTriangleMeshShapeData getPointer(long i) { - return new btTriangleMeshShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btTriangleMeshShapeData m_collisionShapeData(btCollisionShapeData setter); - - public native @ByRef btStridingMeshInterfaceData m_meshInterface(); public native btTriangleMeshShapeData m_meshInterface(btStridingMeshInterfaceData setter); - - public native btQuantizedBvhFloatData m_quantizedFloatBvh(); public native btTriangleMeshShapeData m_quantizedFloatBvh(btQuantizedBvhFloatData setter); - public native btQuantizedBvhDoubleData m_quantizedDoubleBvh(); public native btTriangleMeshShapeData m_quantizedDoubleBvh(btQuantizedBvhDoubleData setter); - - public native btTriangleInfoMapData m_triangleInfoMap(); public native btTriangleMeshShapeData m_triangleInfoMap(btTriangleInfoMapData setter); - - public native float m_collisionMargin(); public native btTriangleMeshShapeData m_collisionMargin(float setter); - - public native @Cast("char") byte m_pad3(int i); public native btTriangleMeshShapeData m_pad3(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_pad3(); - -} - -// clang-format on - - - -// #endif //BT_BVH_TRIANGLE_MESH_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H -// #define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H - -// #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" - -/**The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMeshShape. - * Note that each btBvhTriangleMeshShape still can have its own local scaling, independent from this btScaledBvhTriangleMeshShape 'localScaling' */ -@NoOffset public static class btScaledBvhTriangleMeshShape extends btConcaveShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btScaledBvhTriangleMeshShape(Pointer p) { super(p); } - - - public btScaledBvhTriangleMeshShape(btBvhTriangleMeshShape childShape, @Const @ByRef btVector3 localScaling) { super((Pointer)null); allocate(childShape, localScaling); } - private native void allocate(btBvhTriangleMeshShape childShape, @Const @ByRef btVector3 localScaling); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - public native @Const @ByRef btVector3 getLocalScaling(); - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); - - public native btBvhTriangleMeshShape getChildShape(); - - //debugging - public native @Cast("const char*") BytePointer getName(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btScaledTriangleMeshShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btScaledTriangleMeshShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btScaledTriangleMeshShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btScaledTriangleMeshShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btScaledTriangleMeshShapeData position(long position) { - return (btScaledTriangleMeshShapeData)super.position(position); - } - @Override public btScaledTriangleMeshShapeData getPointer(long i) { - return new btScaledTriangleMeshShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btTriangleMeshShapeData m_trimeshShapeData(); public native btScaledTriangleMeshShapeData m_trimeshShapeData(btTriangleMeshShapeData setter); - - public native @ByRef btVector3FloatData m_localScaling(); public native btScaledTriangleMeshShapeData m_localScaling(btVector3FloatData setter); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btCompoundShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_COMPOUND_SHAPE_H -// #define BT_COMPOUND_SHAPE_H - -// #include "btCollisionShape.h" - -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "btCollisionMargin.h" -// #include "LinearMath/btAlignedObjectArray.h" - -//class btOptimizedBvh; -@Opaque public static class btDbvt extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btDbvt() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDbvt(Pointer p) { super(p); } -} - -public static class btCompoundShapeChild extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCompoundShapeChild() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCompoundShapeChild(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCompoundShapeChild(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCompoundShapeChild position(long position) { - return (btCompoundShapeChild)super.position(position); - } - @Override public btCompoundShapeChild getPointer(long i) { - return new btCompoundShapeChild((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransform m_transform(); public native btCompoundShapeChild m_transform(btTransform setter); - public native btCollisionShape m_childShape(); public native btCompoundShapeChild m_childShape(btCollisionShape setter); - public native int m_childShapeType(); public native btCompoundShapeChild m_childShapeType(int setter); - public native @Cast("btScalar") float m_childMargin(); public native btCompoundShapeChild m_childMargin(float setter); - -} - -public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btCompoundShapeChild c1, @Const @ByRef btCompoundShapeChild c2); - -/** The btCompoundShape allows to store multiple other btCollisionShapes - * This allows for moving concave collision objects. This is more general then the static concave btBvhTriangleMeshShape. - * It has an (optional) dynamic aabb tree to accelerate early rejection tests. - * \todo: This aabb tree can also be use to speed up ray tests on btCompoundShape, see http://code.google.com/p/bullet/issues/detail?id=25 - * Currently, removal of child shapes is only supported when disabling the aabb tree (pass 'false' in the constructor of btCompoundShape) */ -@NoOffset public static class btCompoundShape extends btCollisionShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCompoundShape(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCompoundShape(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btCompoundShape position(long position) { - return (btCompoundShape)super.position(position); - } - @Override public btCompoundShape getPointer(long i) { - return new btCompoundShape((Pointer)this).offsetAddress(i); - } - - - public btCompoundShape(@Cast("bool") boolean enableDynamicAabbTree/*=true*/, int initialChildCapacity/*=0*/) { super((Pointer)null); allocate(enableDynamicAabbTree, initialChildCapacity); } - private native void allocate(@Cast("bool") boolean enableDynamicAabbTree/*=true*/, int initialChildCapacity/*=0*/); - public btCompoundShape() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native void addChildShape(@Const @ByRef btTransform localTransform, btCollisionShape shape); - - /** Remove all children shapes that contain the specified shape */ - public native void removeChildShape(btCollisionShape shape); - - public native void removeChildShapeByIndex(int childShapeindex); - - public native int getNumChildShapes(); - - public native btCollisionShape getChildShape(int index); - - public native @ByRef btTransform getChildTransform(int index); - - /**set a new transform for a child, and update internal data structures (local aabb and dynamic tree) */ - public native void updateChildTransform(int childIndex, @Const @ByRef btTransform newChildTransform, @Cast("bool") boolean shouldRecalculateLocalAabb/*=true*/); - public native void updateChildTransform(int childIndex, @Const @ByRef btTransform newChildTransform); - - public native btCompoundShapeChild getChildList(); - - /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - /** Re-calculate the local Aabb. Is called at the end of removeChildShapes. - Use this yourself if you modify the children or their transforms. */ - public native void recalculateLocalAabb(); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - - public native @Const @ByRef btVector3 getLocalScaling(); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native void setMargin(@Cast("btScalar") float margin); - public native @Cast("btScalar") float getMargin(); - public native @Cast("const char*") BytePointer getName(); - - public native btDbvt getDynamicAabbTree(); - - public native void createAabbTreeFromChildren(); - - /**computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia - * and the center of mass to the current coordinate system. "masses" points to an array of masses of the children. The resulting transform - * "principal" has to be applied inversely to all children transforms in order for the local coordinate system of the compound - * shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform - * of the collision object by the principal transform. */ - public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") FloatPointer masses, @ByRef btTransform principal, @ByRef btVector3 inertia); - public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") FloatBuffer masses, @ByRef btTransform principal, @ByRef btVector3 inertia); - public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") float[] masses, @ByRef btTransform principal, @ByRef btVector3 inertia); - - public native int getUpdateRevision(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -// clang-format off - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btCompoundShapeChildData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCompoundShapeChildData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCompoundShapeChildData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCompoundShapeChildData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCompoundShapeChildData position(long position) { - return (btCompoundShapeChildData)super.position(position); - } - @Override public btCompoundShapeChildData getPointer(long i) { - return new btCompoundShapeChildData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btTransformFloatData m_transform(); public native btCompoundShapeChildData m_transform(btTransformFloatData setter); - public native btCollisionShapeData m_childShape(); public native btCompoundShapeChildData m_childShape(btCollisionShapeData setter); - public native int m_childShapeType(); public native btCompoundShapeChildData m_childShapeType(int setter); - public native float m_childMargin(); public native btCompoundShapeChildData m_childMargin(float setter); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btCompoundShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btCompoundShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btCompoundShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCompoundShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btCompoundShapeData position(long position) { - return (btCompoundShapeData)super.position(position); - } - @Override public btCompoundShapeData getPointer(long i) { - return new btCompoundShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btCompoundShapeData m_collisionShapeData(btCollisionShapeData setter); - - public native btCompoundShapeChildData m_childShapePtr(); public native btCompoundShapeData m_childShapePtr(btCompoundShapeChildData setter); - - public native int m_numChildShapes(); public native btCompoundShapeData m_numChildShapes(int setter); - - public native float m_collisionMargin(); public native btCompoundShapeData m_collisionMargin(float setter); - -} - -// clang-format on - - - -// #endif //BT_COMPOUND_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btTetrahedronShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SIMPLEX_1TO4_SHAPE -// #define BT_SIMPLEX_1TO4_SHAPE - -// #include "btPolyhedralConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" - -/**The btBU_Simplex1to4 implements tetrahedron, triangle, line, vertex collision shapes. In most cases it is better to use btConvexHullShape instead. */ -@NoOffset public static class btBU_Simplex1to4 extends btPolyhedralConvexAabbCachingShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btBU_Simplex1to4(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btBU_Simplex1to4(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btBU_Simplex1to4 position(long position) { - return (btBU_Simplex1to4)super.position(position); - } - @Override public btBU_Simplex1to4 getPointer(long i) { - return new btBU_Simplex1to4((Pointer)this).offsetAddress(i); - } - - - public btBU_Simplex1to4() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btBU_Simplex1to4(@Const @ByRef btVector3 pt0) { super((Pointer)null); allocate(pt0); } - private native void allocate(@Const @ByRef btVector3 pt0); - public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1) { super((Pointer)null); allocate(pt0, pt1); } - private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1); - public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2) { super((Pointer)null); allocate(pt0, pt1, pt2); } - private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2); - public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2, @Const @ByRef btVector3 pt3) { super((Pointer)null); allocate(pt0, pt1, pt2, pt3); } - private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2, @Const @ByRef btVector3 pt3); - - public native void reset(); - - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void addVertex(@Const @ByRef btVector3 pt); - - //PolyhedralConvexShape interface - - public native int getNumVertices(); - - public native int getNumEdges(); - - public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); - - public native void getVertex(int i, @ByRef btVector3 vtx); - - public native int getNumPlanes(); - - public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); - - public native int getIndex(int i); - - public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); - - /**getName is for debugging */ - public native @Cast("const char*") BytePointer getName(); -} - -// #endif //BT_SIMPLEX_1TO4_SHAPE - - -// Parsed from BulletCollision/CollisionShapes/btEmptyShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_EMPTY_SHAPE_H -// #define BT_EMPTY_SHAPE_H - -// #include "btConcaveShape.h" - -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "btCollisionMargin.h" - -/** The btEmptyShape is a collision shape without actual collision detection shape, so most users should ignore this class. - * It can be replaced by another shape during runtime, but the inertia tensor should be recomputed. */ -@NoOffset public static class btEmptyShape extends btConcaveShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btEmptyShape(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btEmptyShape(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btEmptyShape position(long position) { - return (btEmptyShape)super.position(position); - } - @Override public btEmptyShape getPointer(long i) { - return new btEmptyShape((Pointer)this).offsetAddress(i); - } - - - public btEmptyShape() { super((Pointer)null); allocate(); } - private native void allocate(); - - /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - public native @Const @ByRef btVector3 getLocalScaling(); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native @Cast("const char*") BytePointer getName(); - - public native void processAllTriangles(btTriangleCallback arg0, @Const @ByRef btVector3 arg1, @Const @ByRef btVector3 arg2); -} - -// #endif //BT_EMPTY_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btMultiSphereShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_MULTI_SPHERE_MINKOWSKI_H -// #define BT_MULTI_SPHERE_MINKOWSKI_H - -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btAabbUtil2.h" - -/**The btMultiSphereShape represents the convex hull of a collection of spheres. You can create special capsules or other smooth volumes. - * It is possible to animate the spheres for deformation, but call 'recalcLocalAabb' after changing any sphere position/radius */ -@NoOffset public static class btMultiSphereShape extends btConvexInternalAabbCachingShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btMultiSphereShape(Pointer p) { super(p); } - - - public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") FloatPointer radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } - private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") FloatPointer radi, int numSpheres); - public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") FloatBuffer radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } - private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") FloatBuffer radi, int numSpheres); - public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") float[] radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } - private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") float[] radi, int numSpheres); - - /**CollisionShape Interface */ - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - /** btConvexShape Interface */ - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public native int getSphereCount(); - - public native @Const @ByRef btVector3 getSpherePosition(int index); - - public native @Cast("btScalar") float getSphereRadius(int index); - - public native @Cast("const char*") BytePointer getName(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -public static class btPositionAndRadius extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btPositionAndRadius() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btPositionAndRadius(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPositionAndRadius(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btPositionAndRadius position(long position) { - return (btPositionAndRadius)super.position(position); - } - @Override public btPositionAndRadius getPointer(long i) { - return new btPositionAndRadius((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3FloatData m_pos(); public native btPositionAndRadius m_pos(btVector3FloatData setter); - public native float m_radius(); public native btPositionAndRadius m_radius(float setter); -} - -// clang-format off - -public static class btMultiSphereShapeData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btMultiSphereShapeData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btMultiSphereShapeData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btMultiSphereShapeData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btMultiSphereShapeData position(long position) { - return (btMultiSphereShapeData)super.position(position); - } - @Override public btMultiSphereShapeData getPointer(long i) { - return new btMultiSphereShapeData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btMultiSphereShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); - - public native btPositionAndRadius m_localPositionArrayPtr(); public native btMultiSphereShapeData m_localPositionArrayPtr(btPositionAndRadius setter); - public native int m_localPositionArraySize(); public native btMultiSphereShapeData m_localPositionArraySize(int setter); - public native @Cast("char") byte m_padding(int i); public native btMultiSphereShapeData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - -// clang-format on - - - -// #endif //BT_MULTI_SPHERE_MINKOWSKI_H - - -// Parsed from BulletCollision/CollisionShapes/btUniformScalingShape.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_UNIFORM_SCALING_SHAPE_H -// #define BT_UNIFORM_SCALING_SHAPE_H - -// #include "btConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types - -/**The btUniformScalingShape allows to re-use uniform scaled instances of btConvexShape in a memory efficient way. - * Istead of using btUniformScalingShape, it is better to use the non-uniform setLocalScaling method on convex shapes that implement it. */ -@NoOffset public static class btUniformScalingShape extends btConvexShape { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btUniformScalingShape(Pointer p) { super(p); } - - - public btUniformScalingShape(btConvexShape convexChildShape, @Cast("btScalar") float uniformScalingFactor) { super((Pointer)null); allocate(convexChildShape, uniformScalingFactor); } - private native void allocate(btConvexShape convexChildShape, @Cast("btScalar") float uniformScalingFactor); - - public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); - - public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); - - public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); - - public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); - - public native @Cast("btScalar") float getUniformScalingFactor(); - - public native btConvexShape getChildShape(); - - public native @Cast("const char*") BytePointer getName(); - - /////////////////////////// - - /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ - public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void getAabbSlow(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native void setLocalScaling(@Const @ByRef btVector3 scaling); - public native @Const @ByRef btVector3 getLocalScaling(); - - public native void setMargin(@Cast("btScalar") float margin); - public native @Cast("btScalar") float getMargin(); - - public native int getNumPreferredPenetrationDirections(); - - public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); -} - -// #endif //BT_UNIFORM_SCALING_SHAPE_H - - -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/CalculateCombinedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/CalculateCombinedCallback.java new file mode 100644 index 00000000000..d7a93ed6414 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/CalculateCombinedCallback.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +//#define DEBUG_PART_INDEX 1 + +/** These callbacks are used to customize the algorith that combine restitution, friction, damping, Stiffness */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class CalculateCombinedCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CalculateCombinedCallback(Pointer p) { super(p); } + protected CalculateCombinedCallback() { allocate(); } + private native void allocate(); + public native @Cast("btScalar") float call(@Const btCollisionObject body0, @Const btCollisionObject body1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactAddedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactAddedCallback.java new file mode 100644 index 00000000000..d615d66965d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactAddedCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class ContactAddedCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ContactAddedCallback(Pointer p) { super(p); } + protected ContactAddedCallback() { allocate(); } + private native void allocate(); + public native @Cast("bool") boolean call(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper colObj0Wrap, int partId0, int index0, @Const btCollisionObjectWrapper colObj1Wrap, int partId1, int index1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java new file mode 100644 index 00000000000..f24920233c0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** The bt32BitAxisSweep3 allows higher precision quantization and more objects compared to the btAxisSweep3 sweep and prune. + * This comes at the cost of more memory per handle, and a bit slower performance. + * It uses arrays rather then lists for storage of the 3 axis. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class bt32BitAxisSweep3 extends btBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public bt32BitAxisSweep3(Pointer p) { super(p); } + + public bt32BitAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned int") int maxHandles/*=1500000*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax, maxHandles, pairCache, disableRaycastAccelerator); } + private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned int") int maxHandles/*=1500000*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/); + public bt32BitAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax); } + private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btActivatingCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btActivatingCollisionAlgorithm.java new file mode 100644 index 00000000000..5a170db9473 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btActivatingCollisionAlgorithm.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**This class is not enabled yet (work-in-progress) to more aggressively activate objects. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btActivatingCollisionAlgorithm extends btCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btActivatingCollisionAlgorithm(Pointer p) { super(p); } + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java new file mode 100644 index 00000000000..0c13b2c4c6b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** The btAxisSweep3 is an efficient implementation of the 3d axis sweep and prune broadphase. + * It uses arrays rather then lists for storage of the 3 axis. Also it operates using 16 bit integer coordinates instead of floats. + * For large worlds and many objects, use bt32BitAxisSweep3 or btDbvtBroadphase instead. bt32BitAxisSweep3 has higher precision and allows more then 16384 objects at the cost of more memory and bit of performance. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btAxisSweep3 extends btBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAxisSweep3(Pointer p) { super(p); } + + public btAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned short int") short maxHandles/*=16384*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax, maxHandles, pairCache, disableRaycastAccelerator); } + private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax, @Cast("unsigned short int") short maxHandles/*=16384*/, btOverlappingPairCache pairCache/*=0*/, @Cast("bool") boolean disableRaycastAccelerator/*=false*/); + public btAxisSweep3(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax) { super((Pointer)null); allocate(worldAabbMin, worldAabbMax); } + private native void allocate(@Const @ByRef btVector3 worldAabbMin, @Const @ByRef btVector3 worldAabbMax); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java new file mode 100644 index 00000000000..1050b973760 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java @@ -0,0 +1,71 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btBU_Simplex1to4 implements tetrahedron, triangle, line, vertex collision shapes. In most cases it is better to use btConvexHullShape instead. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBU_Simplex1to4 extends btPolyhedralConvexAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBU_Simplex1to4(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBU_Simplex1to4(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBU_Simplex1to4 position(long position) { + return (btBU_Simplex1to4)super.position(position); + } + @Override public btBU_Simplex1to4 getPointer(long i) { + return new btBU_Simplex1to4((Pointer)this).offsetAddress(i); + } + + + public btBU_Simplex1to4() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btBU_Simplex1to4(@Const @ByRef btVector3 pt0) { super((Pointer)null); allocate(pt0); } + private native void allocate(@Const @ByRef btVector3 pt0); + public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1) { super((Pointer)null); allocate(pt0, pt1); } + private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1); + public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2) { super((Pointer)null); allocate(pt0, pt1, pt2); } + private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2); + public btBU_Simplex1to4(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2, @Const @ByRef btVector3 pt3) { super((Pointer)null); allocate(pt0, pt1, pt2, pt3); } + private native void allocate(@Const @ByRef btVector3 pt0, @Const @ByRef btVector3 pt1, @Const @ByRef btVector3 pt2, @Const @ByRef btVector3 pt3); + + public native void reset(); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void addVertex(@Const @ByRef btVector3 pt); + + //PolyhedralConvexShape interface + + public native int getNumVertices(); + + public native int getNumEdges(); + + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + + public native void getVertex(int i, @ByRef btVector3 vtx); + + public native int getNumPlanes(); + + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + + public native int getIndex(int i); + + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + /**getName is for debugging */ + public native @Cast("const char*") BytePointer getName(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxShape.java new file mode 100644 index 00000000000..c9ede4a4286 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxShape.java @@ -0,0 +1,66 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btBoxShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBoxShape extends btPolyhedralConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBoxShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 getHalfExtentsWithMargin(); + + public native @Const @ByRef btVector3 getHalfExtentsWithoutMargin(); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public btBoxShape(@Const @ByRef btVector3 boxHalfExtents) { super((Pointer)null); allocate(boxHalfExtents); } + private native void allocate(@Const @ByRef btVector3 boxHalfExtents); + + public native void setMargin(@Cast("btScalar") float collisionMargin); + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + + public native int getNumPlanes(); + + public native int getNumVertices(); + + public native int getNumEdges(); + + public native void getVertex(int i, @ByRef btVector3 vtx); + + public native void getPlaneEquation(@ByRef btVector4 plane, int i); + + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseAabbCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseAabbCallback.java new file mode 100644 index 00000000000..a14ba40e547 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseAabbCallback.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBroadphaseAabbCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphaseAabbCallback(Pointer p) { super(p); } + + public native @Cast("bool") boolean process(@Const btBroadphaseProxy proxy); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseInterface.java new file mode 100644 index 00000000000..e92763d70e1 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseInterface.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btBroadphaseInterface class provides an interface to detect aabb-overlapping object pairs. + * Some implementations for this broadphase interface include btAxisSweep3, bt32BitAxisSweep3 and btDbvtBroadphase. + * The actual overlapping pair management, storage, adding and removing of pairs is dealt by the btOverlappingPairCache class. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBroadphaseInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphaseInterface(Pointer p) { super(p); } + + + public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); + public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); + public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); + + public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); + + /**calculateOverlappingPairs is optional: incremental algorithms (sweep and prune) might do it during the set aabb */ + public native void calculateOverlappingPairs(btDispatcher dispatcher); + + public native btOverlappingPairCache getOverlappingPairCache(); + + /**getAabb returns the axis aligned bounding box in the 'global' coordinate frame + * will add some transform later */ + public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /**reset broadphase internal structures, to ensure determinism/reproducability */ + public native void resetPool(btDispatcher dispatcher); + + public native void printStats(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePair.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePair.java new file mode 100644 index 00000000000..96acf94eb0a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePair.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btBroadphasePair class contains a pair of aabb-overlapping objects. + * A btDispatcher can search a btCollisionAlgorithm that performs exact/narrowphase collision detection on the actual collision shapes. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBroadphasePair extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphasePair(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBroadphasePair(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBroadphasePair position(long position) { + return (btBroadphasePair)super.position(position); + } + @Override public btBroadphasePair getPointer(long i) { + return new btBroadphasePair((Pointer)this).offsetAddress(i); + } + + public btBroadphasePair() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btBroadphasePair(@ByRef btBroadphaseProxy proxy0, @ByRef btBroadphaseProxy proxy1) { super((Pointer)null); allocate(proxy0, proxy1); } + private native void allocate(@ByRef btBroadphaseProxy proxy0, @ByRef btBroadphaseProxy proxy1); + + public native btBroadphaseProxy m_pProxy0(); public native btBroadphasePair m_pProxy0(btBroadphaseProxy setter); + public native btBroadphaseProxy m_pProxy1(); public native btBroadphasePair m_pProxy1(btBroadphaseProxy setter); + + public native btCollisionAlgorithm m_algorithm(); public native btBroadphasePair m_algorithm(btCollisionAlgorithm setter); + public native Pointer m_internalInfo1(); public native btBroadphasePair m_internalInfo1(Pointer setter); + public native int m_internalTmpValue(); public native btBroadphasePair m_internalTmpValue(int setter); //don't use this data, it will be removed in future version. +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePairSortPredicate.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePairSortPredicate.java new file mode 100644 index 00000000000..b416376c299 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePairSortPredicate.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/* +//comparison for set operation, see Solid DT_Encounter +SIMD_FORCE_INLINE bool operator<(const btBroadphasePair& a, const btBroadphasePair& b) +{ + return a.m_pProxy0 < b.m_pProxy0 || + (a.m_pProxy0 == b.m_pProxy0 && a.m_pProxy1 < b.m_pProxy1); +} +*/ + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBroadphasePairSortPredicate extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btBroadphasePairSortPredicate() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBroadphasePairSortPredicate(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphasePairSortPredicate(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btBroadphasePairSortPredicate position(long position) { + return (btBroadphasePairSortPredicate)super.position(position); + } + @Override public btBroadphasePairSortPredicate getPointer(long i) { + return new btBroadphasePairSortPredicate((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") @Name("operator ()") boolean apply(@Const @ByRef btBroadphasePair a, @Const @ByRef btBroadphasePair b); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java new file mode 100644 index 00000000000..0945c1b2191 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java @@ -0,0 +1,78 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btBroadphaseProxy is the main class that can be used with the Bullet broadphases. + * It stores collision shape type information, collision filter information and a client object, typically a btCollisionObject or btRigidBody. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBroadphaseProxy extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphaseProxy(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBroadphaseProxy(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBroadphaseProxy position(long position) { + return (btBroadphaseProxy)super.position(position); + } + @Override public btBroadphaseProxy getPointer(long i) { + return new btBroadphaseProxy((Pointer)this).offsetAddress(i); + } + + + /**optional filtering to cull potential collisions */ + /** enum btBroadphaseProxy::CollisionFilterGroups */ + public static final int + DefaultFilter = 1, + StaticFilter = 2, + KinematicFilter = 4, + DebrisFilter = 8, + SensorTrigger = 16, + CharacterFilter = 32, + AllFilter = -1; //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger + + //Usually the client btCollisionObject or Rigidbody class + public native Pointer m_clientObject(); public native btBroadphaseProxy m_clientObject(Pointer setter); + public native int m_collisionFilterGroup(); public native btBroadphaseProxy m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native btBroadphaseProxy m_collisionFilterMask(int setter); + + public native int m_uniqueId(); public native btBroadphaseProxy m_uniqueId(int setter); //m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. + + public native @ByRef btVector3 m_aabbMin(); public native btBroadphaseProxy m_aabbMin(btVector3 setter); + public native @ByRef btVector3 m_aabbMax(); public native btBroadphaseProxy m_aabbMax(btVector3 setter); + + public native int getUid(); + + //used for memory pools + public btBroadphaseProxy() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btBroadphaseProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask); } + private native void allocate(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); + + public static native @Cast("bool") boolean isPolyhedral(int proxyType); + + public static native @Cast("bool") boolean isConvex(int proxyType); + + public static native @Cast("bool") boolean isNonMoving(int proxyType); + + public static native @Cast("bool") boolean isConcave(int proxyType); + public static native @Cast("bool") boolean isCompound(int proxyType); + + public static native @Cast("bool") boolean isSoftBody(int proxyType); + + public static native @Cast("bool") boolean isInfinite(int proxyType); + + public static native @Cast("bool") boolean isConvex2d(int proxyType); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseRayCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseRayCallback.java new file mode 100644 index 00000000000..7ab609e555a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseRayCallback.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBroadphaseRayCallback extends btBroadphaseAabbCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBroadphaseRayCallback(Pointer p) { super(p); } + + /**added some cached data to accelerate ray-AABB tests */ + public native @ByRef btVector3 m_rayDirectionInverse(); public native btBroadphaseRayCallback m_rayDirectionInverse(btVector3 setter); + public native @Cast("unsigned int") int m_signs(int i); public native btBroadphaseRayCallback m_signs(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer m_signs(); + public native @Cast("btScalar") float m_lambda_max(); public native btBroadphaseRayCallback m_lambda_max(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java new file mode 100644 index 00000000000..e057cd099dd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btBvhSubtreeInfo provides info to gather a subtree of limited size */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBvhSubtreeInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBvhSubtreeInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBvhSubtreeInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBvhSubtreeInfo position(long position) { + return (btBvhSubtreeInfo)super.position(position); + } + @Override public btBvhSubtreeInfo getPointer(long i) { + return new btBvhSubtreeInfo((Pointer)this).offsetAddress(i); + } + + + //12 bytes + public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native btBvhSubtreeInfo m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native btBvhSubtreeInfo m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); + //4 bytes, points to the root of the subtree + public native int m_rootNodeIndex(); public native btBvhSubtreeInfo m_rootNodeIndex(int setter); + //4 bytes + public native int m_subtreeSize(); public native btBvhSubtreeInfo m_subtreeSize(int setter); + public native int m_padding(int i); public native btBvhSubtreeInfo m_padding(int i, int setter); + @MemberGetter public native IntPointer m_padding(); + + public btBvhSubtreeInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void setAabbFromQuantizeNode(@Const @ByRef btQuantizedBvhNode quantizedNode); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java new file mode 100644 index 00000000000..da53fd54ee6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off +// parser needs * with the name +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBvhSubtreeInfoData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btBvhSubtreeInfoData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBvhSubtreeInfoData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBvhSubtreeInfoData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btBvhSubtreeInfoData position(long position) { + return (btBvhSubtreeInfoData)super.position(position); + } + @Override public btBvhSubtreeInfoData getPointer(long i) { + return new btBvhSubtreeInfoData((Pointer)this).offsetAddress(i); + } + + public native int m_rootNodeIndex(); public native btBvhSubtreeInfoData m_rootNodeIndex(int setter); + public native int m_subtreeSize(); public native btBvhSubtreeInfoData m_subtreeSize(int setter); + public native @Cast("unsigned short") short m_quantizedAabbMin(int i); public native btBvhSubtreeInfoData m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short") short m_quantizedAabbMax(int i); public native btBvhSubtreeInfoData m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMax(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java new file mode 100644 index 00000000000..99306076b37 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java @@ -0,0 +1,82 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btBvhTriangleMeshShape is a static-triangle mesh shape, it can only be used for fixed/non-moving objects. + * If you required moving concave triangle meshes, it is recommended to perform convex decomposition + * using HACD, see Bullet/Demos/ConvexDecompositionDemo. + * Alternatively, you can use btGimpactMeshShape for moving concave triangle meshes. + * btBvhTriangleMeshShape has several optimizations, such as bounding volume hierarchy and + * cache friendly traversal for PlayStation 3 Cell SPU. + * It is recommended to enable useQuantizedAabbCompression for better memory usage. + * It takes a triangle mesh as input, for example a btTriangleMesh or btTriangleIndexVertexArray. The btBvhTriangleMeshShape class allows for triangle mesh deformations by a refit or partialRefit method. + * Instead of building the bounding volume hierarchy acceleration structure, it is also possible to serialize (save) and deserialize (load) the structure from disk. + * See Demos\ConcaveDemo\ConcavePhysicsDemo.cpp for an example. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBvhTriangleMeshShape extends btTriangleMeshShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBvhTriangleMeshShape(Pointer p) { super(p); } + + + public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Cast("bool") boolean buildBvh/*=true*/) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, buildBvh); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Cast("bool") boolean buildBvh/*=true*/); + public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression); + + /**optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb */ + public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("bool") boolean buildBvh/*=true*/) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax, buildBvh); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("bool") boolean buildBvh/*=true*/); + public btBvhTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); + + public native @Cast("bool") boolean getOwnsBvh(); + + public native void performRaycast(btTriangleCallback callback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget); + public native void performConvexcast(btTriangleCallback callback, @Const @ByRef btVector3 boxSource, @Const @ByRef btVector3 boxTarget, @Const @ByRef btVector3 boxMin, @Const @ByRef btVector3 boxMax); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void refitTree(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + /**for a fast incremental refit of parts of the tree. Note: the entire AABB of the tree will become more conservative, it never shrinks */ + public native void partialRefitTree(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native btOptimizedBvh getOptimizedBvh(); + + public native void setOptimizedBvh(btOptimizedBvh bvh, @Const @ByRef(nullValue = "btVector3(1, 1, 1)") btVector3 localScaling); + public native void setOptimizedBvh(btOptimizedBvh bvh); + + public native void buildOptimizedBvh(); + + public native @Cast("bool") boolean usesQuantizedAabbCompression(); + + public native void setTriangleInfoMap(btTriangleInfoMap triangleInfoMap); + + public native btTriangleInfoMap getTriangleInfoMap(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void serializeSingleBvh(btSerializer serializer); + + public native void serializeSingleTriangleInfoMap(btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShape.java new file mode 100644 index 00000000000..c217a84068e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShape.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + // for the types + +/**The btCapsuleShape represents a capsule around the Y axis, there is also the btCapsuleShapeX aligned around the X axis and btCapsuleShapeZ around the Z axis. + * The total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. + * The btCapsuleShape is a convex hull of two spheres. The btMultiSphereShape is a more general collision shape that takes the convex hull of multiple sphere, so it can also represent a capsule when just using two spheres. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCapsuleShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCapsuleShape(Pointer p) { super(p); } + + + public btCapsuleShape(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + /**CollisionShape Interface */ + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + /** btConvexShape Interface */ + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void setMargin(@Cast("btScalar") float collisionMargin); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native @Cast("const char*") BytePointer getName(); + + public native int getUpAxis(); + + public native @Cast("btScalar") float getRadius(); + + public native @Cast("btScalar") float getHalfHeight(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void deSerializeFloat(btCapsuleShapeData dataBuffer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java new file mode 100644 index 00000000000..de776202576 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCapsuleShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCapsuleShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCapsuleShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCapsuleShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCapsuleShapeData position(long position) { + return (btCapsuleShapeData)super.position(position); + } + @Override public btCapsuleShapeData getPointer(long i) { + return new btCapsuleShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btCapsuleShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native int m_upAxis(); public native btCapsuleShapeData m_upAxis(int setter); + + public native @Cast("char") byte m_padding(int i); public native btCapsuleShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java new file mode 100644 index 00000000000..a11d7b0a150 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btCapsuleShapeX represents a capsule around the Z axis + * the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCapsuleShapeX extends btCapsuleShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCapsuleShapeX(Pointer p) { super(p); } + + public btCapsuleShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java new file mode 100644 index 00000000000..c713091c21f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btCapsuleShapeZ represents a capsule around the Z axis + * the total height is height+2*radius, so the height is just the height between the center of each 'sphere' of the capsule caps. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCapsuleShapeZ extends btCapsuleShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCapsuleShapeZ(Pointer p) { super(p); } + + public btCapsuleShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCharIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCharIndexTripletData.java new file mode 100644 index 00000000000..7be9141450a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCharIndexTripletData.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCharIndexTripletData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCharIndexTripletData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCharIndexTripletData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCharIndexTripletData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCharIndexTripletData position(long position) { + return (btCharIndexTripletData)super.position(position); + } + @Override public btCharIndexTripletData getPointer(long i) { + return new btCharIndexTripletData((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned char") byte m_values(int i); public native btCharIndexTripletData m_values(int i, byte setter); + @MemberGetter public native @Cast("unsigned char*") BytePointer m_values(); + public native @Cast("char") byte m_pad(); public native btCharIndexTripletData m_pad(byte setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java new file mode 100644 index 00000000000..e752417fa42 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java @@ -0,0 +1,22 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionAlgorithm extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionAlgorithm() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionAlgorithm(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java new file mode 100644 index 00000000000..eb999318b55 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionAlgorithmConstructionInfo extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionAlgorithmConstructionInfo() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionAlgorithmConstructionInfo(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java new file mode 100644 index 00000000000..52e5e0675f3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**Used by the btCollisionDispatcher to register and create instances for btCollisionAlgorithm */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionAlgorithmCreateFunc extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionAlgorithmCreateFunc(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionAlgorithmCreateFunc(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCollisionAlgorithmCreateFunc position(long position) { + return (btCollisionAlgorithmCreateFunc)super.position(position); + } + @Override public btCollisionAlgorithmCreateFunc getPointer(long i) { + return new btCollisionAlgorithmCreateFunc((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") boolean m_swapped(); public native btCollisionAlgorithmCreateFunc m_swapped(boolean setter); + + public btCollisionAlgorithmCreateFunc() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo arg0, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java new file mode 100644 index 00000000000..1e8899d7fae --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionConfiguration extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionConfiguration() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionConfiguration(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcher.java new file mode 100644 index 00000000000..c91feab9ebe --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcher.java @@ -0,0 +1,78 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btCollisionDispatcher supports algorithms that handle ConvexConvex and ConvexConcave collision pairs. + * Time of Impact, Closest Points and Penetration Depth. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionDispatcher extends btDispatcher { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionDispatcher(Pointer p) { super(p); } + + /** enum btCollisionDispatcher::DispatcherFlags */ + public static final int + CD_STATIC_STATIC_REPORTED = 1, + CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD = 2, + CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION = 4; + + public native int getDispatcherFlags(); + + public native void setDispatcherFlags(int flags); + + /**registerCollisionCreateFunc allows registration of custom/alternative collision create functions */ + public native void registerCollisionCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc createFunc); + + public native void registerClosestPointsCreateFunc(int proxyType0, int proxyType1, btCollisionAlgorithmCreateFunc createFunc); + + public native int getNumManifolds(); + + public native @Cast("btPersistentManifold**") PointerPointer getInternalManifoldPointer(); + + public native btPersistentManifold getManifoldByIndexInternal(int index); + + public btCollisionDispatcher(btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(collisionConfiguration); } + private native void allocate(btCollisionConfiguration collisionConfiguration); + + public native btPersistentManifold getNewManifold(@Const btCollisionObject b0, @Const btCollisionObject b1); + + public native void releaseManifold(btPersistentManifold manifold); + + public native void clearManifold(btPersistentManifold manifold); + + public native btCollisionAlgorithm findAlgorithm(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold, @Cast("ebtDispatcherQueryType") int queryType); + + public native @Cast("bool") boolean needsCollision(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native @Cast("bool") boolean needsResponse(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native void dispatchAllCollisionPairs(btOverlappingPairCache pairCache, @Const @ByRef btDispatcherInfo dispatchInfo, btDispatcher dispatcher); + + public native void setNearCallback(btNearCallback nearCallback); + + public native btNearCallback getNearCallback(); + + //by default, Bullet will use this near callback + public static native void defaultNearCallback(@ByRef btBroadphasePair collisionPair, @ByRef btCollisionDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); + + public native Pointer allocateCollisionAlgorithm(int size); + + public native void freeCollisionAlgorithm(Pointer ptr); + + public native btCollisionConfiguration getCollisionConfiguration(); + + public native void setCollisionConfiguration(btCollisionConfiguration config); + + public native btPoolAllocator getInternalManifoldPool(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObject.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObject.java new file mode 100644 index 00000000000..4ea0d122d89 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObject.java @@ -0,0 +1,233 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +// #endif + +/** btCollisionObject can be used to manage collision detection objects. + * btCollisionObject maintains all information that is needed for a collision detection: Shape, Transform and AABB proxy. + * They can be added to the btCollisionWorld. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionObject extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObject(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionObject(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCollisionObject position(long position) { + return (btCollisionObject)super.position(position); + } + @Override public btCollisionObject getPointer(long i) { + return new btCollisionObject((Pointer)this).offsetAddress(i); + } + + + /** enum btCollisionObject::CollisionFlags */ + public static final int + CF_DYNAMIC_OBJECT = 0, + CF_STATIC_OBJECT = 1, + CF_KINEMATIC_OBJECT = 2, + CF_NO_CONTACT_RESPONSE = 4, + CF_CUSTOM_MATERIAL_CALLBACK = 8, //this allows per-triangle material (friction/restitution) + CF_CHARACTER_OBJECT = 16, + CF_DISABLE_VISUALIZE_OBJECT = 32, //disable debug drawing + CF_DISABLE_SPU_COLLISION_PROCESSING = 64, //disable parallel/SPU processing + CF_HAS_CONTACT_STIFFNESS_DAMPING = 128, + CF_HAS_CUSTOM_DEBUG_RENDERING_COLOR = 256, + CF_HAS_FRICTION_ANCHOR = 512, + CF_HAS_COLLISION_SOUND_TRIGGER = 1024; + + /** enum btCollisionObject::CollisionObjectTypes */ + public static final int + CO_COLLISION_OBJECT = 1, + CO_RIGID_BODY = 2, + /**CO_GHOST_OBJECT keeps track of all objects overlapping its AABB and that pass its collision filter + * It is useful for collision sensors, explosion objects, character controller etc. */ + CO_GHOST_OBJECT = 4, + CO_SOFT_BODY = 8, + CO_HF_FLUID = 16, + CO_USER_TYPE = 32, + CO_FEATHERSTONE_LINK = 64; + + /** enum btCollisionObject::AnisotropicFrictionFlags */ + public static final int + CF_ANISOTROPIC_FRICTION_DISABLED = 0, + CF_ANISOTROPIC_FRICTION = 1, + CF_ANISOTROPIC_ROLLING_FRICTION = 2; + + public native @Cast("bool") boolean mergesSimulationIslands(); + + public native @Const @ByRef btVector3 getAnisotropicFriction(); + public native void setAnisotropicFriction(@Const @ByRef btVector3 anisotropicFriction, int frictionMode/*=btCollisionObject::CF_ANISOTROPIC_FRICTION*/); + public native void setAnisotropicFriction(@Const @ByRef btVector3 anisotropicFriction); + public native @Cast("bool") boolean hasAnisotropicFriction(int frictionMode/*=btCollisionObject::CF_ANISOTROPIC_FRICTION*/); + public native @Cast("bool") boolean hasAnisotropicFriction(); + + /**the constraint solver can discard solving contacts, if the distance is above this threshold. 0 by default. + * Note that using contacts with positive distance can improve stability. It increases, however, the chance of colliding with degerate contacts, such as 'interior' triangle edges */ + public native void setContactProcessingThreshold(@Cast("btScalar") float contactProcessingThreshold); + public native @Cast("btScalar") float getContactProcessingThreshold(); + + public native @Cast("bool") boolean isStaticObject(); + + public native @Cast("bool") boolean isKinematicObject(); + + public native @Cast("bool") boolean isStaticOrKinematicObject(); + + public native @Cast("bool") boolean hasContactResponse(); + + public btCollisionObject() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void setCollisionShape(btCollisionShape collisionShape); + + public native btCollisionShape getCollisionShape(); + + public native void setIgnoreCollisionCheck(@Const btCollisionObject co, @Cast("bool") boolean ignoreCollisionCheck); + + public native int getNumObjectsWithoutCollision(); + + public native @Const btCollisionObject getObjectWithoutCollision(int index); + + public native @Cast("bool") boolean checkCollideWithOverride(@Const btCollisionObject co); + + /**Avoid using this internal API call, the extension pointer is used by some Bullet extensions. + * If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead. */ + public native Pointer internalGetExtensionPointer(); + /**Avoid using this internal API call, the extension pointer is used by some Bullet extensions + * If you need to store your own user pointer, use 'setUserPointer/getUserPointer' instead. */ + public native void internalSetExtensionPointer(Pointer pointer); + + public native int getActivationState(); + + public native void setActivationState(int newState); + + public native void setDeactivationTime(@Cast("btScalar") float time); + public native @Cast("btScalar") float getDeactivationTime(); + + public native void forceActivationState(int newState); + + public native void activate(@Cast("bool") boolean forceActivation/*=false*/); + public native void activate(); + + public native @Cast("bool") boolean isActive(); + + public native void setRestitution(@Cast("btScalar") float rest); + public native @Cast("btScalar") float getRestitution(); + public native void setFriction(@Cast("btScalar") float frict); + public native @Cast("btScalar") float getFriction(); + + public native void setRollingFriction(@Cast("btScalar") float frict); + public native @Cast("btScalar") float getRollingFriction(); + public native void setSpinningFriction(@Cast("btScalar") float frict); + public native @Cast("btScalar") float getSpinningFriction(); + public native void setContactStiffnessAndDamping(@Cast("btScalar") float stiffness, @Cast("btScalar") float damping); + + public native @Cast("btScalar") float getContactStiffness(); + + public native @Cast("btScalar") float getContactDamping(); + + /**reserved for Bullet internal usage */ + public native int getInternalType(); + + public native @ByRef btTransform getWorldTransform(); + + public native void setWorldTransform(@Const @ByRef btTransform worldTrans); + + public native btBroadphaseProxy getBroadphaseHandle(); + + public native void setBroadphaseHandle(btBroadphaseProxy handle); + + public native @ByRef btTransform getInterpolationWorldTransform(); + + public native void setInterpolationWorldTransform(@Const @ByRef btTransform trans); + + public native void setInterpolationLinearVelocity(@Const @ByRef btVector3 linvel); + + public native void setInterpolationAngularVelocity(@Const @ByRef btVector3 angvel); + + public native @Const @ByRef btVector3 getInterpolationLinearVelocity(); + + public native @Const @ByRef btVector3 getInterpolationAngularVelocity(); + + public native int getIslandTag(); + + public native void setIslandTag(int tag); + + public native int getCompanionId(); + + public native void setCompanionId(int id); + + public native int getWorldArrayIndex(); + + // only should be called by CollisionWorld + public native void setWorldArrayIndex(int ix); + + public native @Cast("btScalar") float getHitFraction(); + + public native void setHitFraction(@Cast("btScalar") float hitFraction); + + public native int getCollisionFlags(); + + public native void setCollisionFlags(int flags); + + /**Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: */ + public native @Cast("btScalar") float getCcdSweptSphereRadius(); + + /**Swept sphere radius (0.0 by default), see btConvexConvexAlgorithm:: */ + public native void setCcdSweptSphereRadius(@Cast("btScalar") float radius); + + public native @Cast("btScalar") float getCcdMotionThreshold(); + + public native @Cast("btScalar") float getCcdSquareMotionThreshold(); + + /** Don't do continuous collision detection if the motion (in one step) is less then m_ccdMotionThreshold */ + public native void setCcdMotionThreshold(@Cast("btScalar") float ccdMotionThreshold); + + /**users can point to their objects, userPointer is not used by Bullet */ + public native Pointer getUserPointer(); + + public native int getUserIndex(); + + public native int getUserIndex2(); + + public native int getUserIndex3(); + + /**users can point to their objects, userPointer is not used by Bullet */ + public native void setUserPointer(Pointer userPointer); + + /**users can point to their objects, userPointer is not used by Bullet */ + public native void setUserIndex(int index); + + public native void setUserIndex2(int index); + + public native void setUserIndex3(int index); + + public native int getUpdateRevisionInternal(); + + public native void setCustomDebugColor(@Const @ByRef btVector3 colorRGB); + + public native void removeCustomDebugColor(); + + public native @Cast("bool") boolean getCustomDebugColor(@ByRef btVector3 colorRGB); + + public native @Cast("bool") boolean checkCollideWith(@Const btCollisionObject co); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void serializeSingleObject(btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectDoubleData.java new file mode 100644 index 00000000000..0b3d564db12 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectDoubleData.java @@ -0,0 +1,67 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionObjectDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCollisionObjectDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionObjectDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObjectDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCollisionObjectDoubleData position(long position) { + return (btCollisionObjectDoubleData)super.position(position); + } + @Override public btCollisionObjectDoubleData getPointer(long i) { + return new btCollisionObjectDoubleData((Pointer)this).offsetAddress(i); + } + + public native Pointer m_broadphaseHandle(); public native btCollisionObjectDoubleData m_broadphaseHandle(Pointer setter); + public native Pointer m_collisionShape(); public native btCollisionObjectDoubleData m_collisionShape(Pointer setter); + public native btCollisionShapeData m_rootCollisionShape(); public native btCollisionObjectDoubleData m_rootCollisionShape(btCollisionShapeData setter); + public native @Cast("char*") BytePointer m_name(); public native btCollisionObjectDoubleData m_name(BytePointer setter); + + public native @ByRef btTransformDoubleData m_worldTransform(); public native btCollisionObjectDoubleData m_worldTransform(btTransformDoubleData setter); + public native @ByRef btTransformDoubleData m_interpolationWorldTransform(); public native btCollisionObjectDoubleData m_interpolationWorldTransform(btTransformDoubleData setter); + public native @ByRef btVector3DoubleData m_interpolationLinearVelocity(); public native btCollisionObjectDoubleData m_interpolationLinearVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_interpolationAngularVelocity(); public native btCollisionObjectDoubleData m_interpolationAngularVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_anisotropicFriction(); public native btCollisionObjectDoubleData m_anisotropicFriction(btVector3DoubleData setter); + public native double m_contactProcessingThreshold(); public native btCollisionObjectDoubleData m_contactProcessingThreshold(double setter); + public native double m_deactivationTime(); public native btCollisionObjectDoubleData m_deactivationTime(double setter); + public native double m_friction(); public native btCollisionObjectDoubleData m_friction(double setter); + public native double m_rollingFriction(); public native btCollisionObjectDoubleData m_rollingFriction(double setter); + public native double m_contactDamping(); public native btCollisionObjectDoubleData m_contactDamping(double setter); + public native double m_contactStiffness(); public native btCollisionObjectDoubleData m_contactStiffness(double setter); + public native double m_restitution(); public native btCollisionObjectDoubleData m_restitution(double setter); + public native double m_hitFraction(); public native btCollisionObjectDoubleData m_hitFraction(double setter); + public native double m_ccdSweptSphereRadius(); public native btCollisionObjectDoubleData m_ccdSweptSphereRadius(double setter); + public native double m_ccdMotionThreshold(); public native btCollisionObjectDoubleData m_ccdMotionThreshold(double setter); + public native int m_hasAnisotropicFriction(); public native btCollisionObjectDoubleData m_hasAnisotropicFriction(int setter); + public native int m_collisionFlags(); public native btCollisionObjectDoubleData m_collisionFlags(int setter); + public native int m_islandTag1(); public native btCollisionObjectDoubleData m_islandTag1(int setter); + public native int m_companionId(); public native btCollisionObjectDoubleData m_companionId(int setter); + public native int m_activationState1(); public native btCollisionObjectDoubleData m_activationState1(int setter); + public native int m_internalType(); public native btCollisionObjectDoubleData m_internalType(int setter); + public native int m_checkCollideWith(); public native btCollisionObjectDoubleData m_checkCollideWith(int setter); + public native int m_collisionFilterGroup(); public native btCollisionObjectDoubleData m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native btCollisionObjectDoubleData m_collisionFilterMask(int setter); + public native int m_uniqueId(); public native btCollisionObjectDoubleData m_uniqueId(int setter);//m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectFloatData.java new file mode 100644 index 00000000000..81adb3f9edb --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectFloatData.java @@ -0,0 +1,65 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionObjectFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCollisionObjectFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionObjectFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObjectFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCollisionObjectFloatData position(long position) { + return (btCollisionObjectFloatData)super.position(position); + } + @Override public btCollisionObjectFloatData getPointer(long i) { + return new btCollisionObjectFloatData((Pointer)this).offsetAddress(i); + } + + public native Pointer m_broadphaseHandle(); public native btCollisionObjectFloatData m_broadphaseHandle(Pointer setter); + public native Pointer m_collisionShape(); public native btCollisionObjectFloatData m_collisionShape(Pointer setter); + public native btCollisionShapeData m_rootCollisionShape(); public native btCollisionObjectFloatData m_rootCollisionShape(btCollisionShapeData setter); + public native @Cast("char*") BytePointer m_name(); public native btCollisionObjectFloatData m_name(BytePointer setter); + + public native @ByRef btTransformFloatData m_worldTransform(); public native btCollisionObjectFloatData m_worldTransform(btTransformFloatData setter); + public native @ByRef btTransformFloatData m_interpolationWorldTransform(); public native btCollisionObjectFloatData m_interpolationWorldTransform(btTransformFloatData setter); + public native @ByRef btVector3FloatData m_interpolationLinearVelocity(); public native btCollisionObjectFloatData m_interpolationLinearVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_interpolationAngularVelocity(); public native btCollisionObjectFloatData m_interpolationAngularVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_anisotropicFriction(); public native btCollisionObjectFloatData m_anisotropicFriction(btVector3FloatData setter); + public native float m_contactProcessingThreshold(); public native btCollisionObjectFloatData m_contactProcessingThreshold(float setter); + public native float m_deactivationTime(); public native btCollisionObjectFloatData m_deactivationTime(float setter); + public native float m_friction(); public native btCollisionObjectFloatData m_friction(float setter); + public native float m_rollingFriction(); public native btCollisionObjectFloatData m_rollingFriction(float setter); + public native float m_contactDamping(); public native btCollisionObjectFloatData m_contactDamping(float setter); + public native float m_contactStiffness(); public native btCollisionObjectFloatData m_contactStiffness(float setter); + public native float m_restitution(); public native btCollisionObjectFloatData m_restitution(float setter); + public native float m_hitFraction(); public native btCollisionObjectFloatData m_hitFraction(float setter); + public native float m_ccdSweptSphereRadius(); public native btCollisionObjectFloatData m_ccdSweptSphereRadius(float setter); + public native float m_ccdMotionThreshold(); public native btCollisionObjectFloatData m_ccdMotionThreshold(float setter); + public native int m_hasAnisotropicFriction(); public native btCollisionObjectFloatData m_hasAnisotropicFriction(int setter); + public native int m_collisionFlags(); public native btCollisionObjectFloatData m_collisionFlags(int setter); + public native int m_islandTag1(); public native btCollisionObjectFloatData m_islandTag1(int setter); + public native int m_companionId(); public native btCollisionObjectFloatData m_companionId(int setter); + public native int m_activationState1(); public native btCollisionObjectFloatData m_activationState1(int setter); + public native int m_internalType(); public native btCollisionObjectFloatData m_internalType(int setter); + public native int m_checkCollideWith(); public native btCollisionObjectFloatData m_checkCollideWith(int setter); + public native int m_collisionFilterGroup(); public native btCollisionObjectFloatData m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native btCollisionObjectFloatData m_collisionFilterMask(int setter); + public native int m_uniqueId(); public native btCollisionObjectFloatData m_uniqueId(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java new file mode 100644 index 00000000000..b2169399148 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionObjectWrapper extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionObjectWrapper() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObjectWrapper(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShape.java new file mode 100644 index 00000000000..5175acacba8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShape.java @@ -0,0 +1,89 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btCollisionShape class provides an interface for collision shapes that can be shared among btCollisionObjects. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionShape extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionShape(Pointer p) { super(p); } + + + /**getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t. */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef FloatPointer radius); + public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef FloatBuffer radius); + public native void getBoundingSphere(@ByRef btVector3 center, @Cast("btScalar*") @ByRef float[] radius); + + /**getAngularMotionDisc returns the maximum radius needed for Conservative Advancement to handle time-of-impact with rotations. */ + public native @Cast("btScalar") float getAngularMotionDisc(); + + public native @Cast("btScalar") float getContactBreakingThreshold(@Cast("btScalar") float defaultContactThresholdFactor); + + /**calculateTemporalAabb calculates the enclosing aabb for the moving object over interval [0..timeStep) + * result is conservative */ + public native void calculateTemporalAabb(@Const @ByRef btTransform curTrans, @Const @ByRef btVector3 linvel, @Const @ByRef btVector3 angvel, @Cast("btScalar") float timeStep, @ByRef btVector3 temporalAabbMin, @ByRef btVector3 temporalAabbMax); + + public native @Cast("bool") boolean isPolyhedral(); + + public native @Cast("bool") boolean isConvex2d(); + + public native @Cast("bool") boolean isConvex(); + public native @Cast("bool") boolean isNonMoving(); + public native @Cast("bool") boolean isConcave(); + public native @Cast("bool") boolean isCompound(); + + public native @Cast("bool") boolean isSoftBody(); + + /**isInfinite is used to catch simulation error (aabb check) */ + public native @Cast("bool") boolean isInfinite(); + +// #ifndef __SPU__ + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + //debugging support + public native @Cast("const char*") BytePointer getName(); +// #endif //__SPU__ + + public native int getShapeType(); + + /**the getAnisotropicRollingFrictionDirection can be used in combination with setAnisotropicFriction + * See Bullet/Demos/RollingFrictionDemo for an example */ + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + + /**optional user data pointer */ + public native void setUserPointer(Pointer userPtr); + + public native Pointer getUserPointer(); + public native void setUserIndex(int index); + + public native int getUserIndex(); + + public native void setUserIndex2(int index); + + public native int getUserIndex2(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void serializeSingleShape(btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShapeData.java new file mode 100644 index 00000000000..a3e641c68ec --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShapeData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off +// parser needs * with the name +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCollisionShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCollisionShapeData position(long position) { + return (btCollisionShapeData)super.position(position); + } + @Override public btCollisionShapeData getPointer(long i) { + return new btCollisionShapeData((Pointer)this).offsetAddress(i); + } + + public native @Cast("char*") BytePointer m_name(); public native btCollisionShapeData m_name(BytePointer setter); + public native int m_shapeType(); public native btCollisionShapeData m_shapeType(int setter); + public native @Cast("char") byte m_padding(int i); public native btCollisionShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java new file mode 100644 index 00000000000..8fe49f787fa --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java @@ -0,0 +1,287 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**CollisionWorld is interface and container for the collision detection */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionWorld extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionWorld(Pointer p) { super(p); } + + //this constructor doesn't own the dispatcher and paircache/broadphase + public btCollisionWorld(btDispatcher dispatcher, btBroadphaseInterface broadphasePairCache, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, broadphasePairCache, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface broadphasePairCache, btCollisionConfiguration collisionConfiguration); + + public native void setBroadphase(btBroadphaseInterface pairCache); + + public native btBroadphaseInterface getBroadphase(); + + public native btOverlappingPairCache getPairCache(); + + public native btDispatcher getDispatcher(); + + public native void updateSingleAabb(btCollisionObject colObj); + + public native void updateAabbs(); + + /**the computeOverlappingPairs is usually already called by performDiscreteCollisionDetection (or stepSimulation) + * it can be useful to use if you perform ray tests without collision detection/simulation */ + public native void computeOverlappingPairs(); + + public native void setDebugDrawer(btIDebugDraw debugDrawer); + + public native btIDebugDraw getDebugDrawer(); + + public native void debugDrawWorld(); + + public native void debugDrawObject(@Const @ByRef btTransform worldTransform, @Const btCollisionShape shape, @Const @ByRef btVector3 color); + + /**LocalShapeInfo gives extra information for complex shapes + * Currently, only btTriangleMeshShape is available, so it just contains triangleIndex and subpart */ + public static class LocalShapeInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public LocalShapeInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public LocalShapeInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LocalShapeInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public LocalShapeInfo position(long position) { + return (LocalShapeInfo)super.position(position); + } + @Override public LocalShapeInfo getPointer(long i) { + return new LocalShapeInfo((Pointer)this).offsetAddress(i); + } + + public native int m_shapePart(); public native LocalShapeInfo m_shapePart(int setter); + public native int m_triangleIndex(); public native LocalShapeInfo m_triangleIndex(int setter); + + //const btCollisionShape* m_shapeTemp; + //const btTransform* m_shapeLocalTransform; + } + + @NoOffset public static class LocalRayResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LocalRayResult(Pointer p) { super(p); } + + public LocalRayResult(@Const btCollisionObject collisionObject, + LocalShapeInfo localShapeInfo, + @Const @ByRef btVector3 hitNormalLocal, + @Cast("btScalar") float hitFraction) { super((Pointer)null); allocate(collisionObject, localShapeInfo, hitNormalLocal, hitFraction); } + private native void allocate(@Const btCollisionObject collisionObject, + LocalShapeInfo localShapeInfo, + @Const @ByRef btVector3 hitNormalLocal, + @Cast("btScalar") float hitFraction); + + public native @Const btCollisionObject m_collisionObject(); public native LocalRayResult m_collisionObject(btCollisionObject setter); + public native LocalShapeInfo m_localShapeInfo(); public native LocalRayResult m_localShapeInfo(LocalShapeInfo setter); + public native @ByRef btVector3 m_hitNormalLocal(); public native LocalRayResult m_hitNormalLocal(btVector3 setter); + public native @Cast("btScalar") float m_hitFraction(); public native LocalRayResult m_hitFraction(float setter); + } + + /**RayResultCallback is used to report new raycast results */ + @NoOffset public static class RayResultCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RayResultCallback(Pointer p) { super(p); } + + public native @Cast("btScalar") float m_closestHitFraction(); public native RayResultCallback m_closestHitFraction(float setter); + public native @Const btCollisionObject m_collisionObject(); public native RayResultCallback m_collisionObject(btCollisionObject setter); + public native int m_collisionFilterGroup(); public native RayResultCallback m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native RayResultCallback m_collisionFilterMask(int setter); + //@BP Mod - Custom flags, currently used to enable backface culling on tri-meshes, see btRaycastCallback.h. Apply any of the EFlags defined there on m_flags here to invoke. + public native @Cast("unsigned int") int m_flags(); public native RayResultCallback m_flags(int setter); + public native @Cast("bool") boolean hasHit(); + + public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); + } + + @NoOffset public static class ClosestRayResultCallback extends RayResultCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ClosestRayResultCallback(Pointer p) { super(p); } + + public ClosestRayResultCallback(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld) { super((Pointer)null); allocate(rayFromWorld, rayToWorld); } + private native void allocate(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld); + + public native @ByRef btVector3 m_rayFromWorld(); public native ClosestRayResultCallback m_rayFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction + public native @ByRef btVector3 m_rayToWorld(); public native ClosestRayResultCallback m_rayToWorld(btVector3 setter); + + public native @ByRef btVector3 m_hitNormalWorld(); public native ClosestRayResultCallback m_hitNormalWorld(btVector3 setter); + public native @ByRef btVector3 m_hitPointWorld(); public native ClosestRayResultCallback m_hitPointWorld(btVector3 setter); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); + } + + @NoOffset public static class AllHitsRayResultCallback extends RayResultCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public AllHitsRayResultCallback(Pointer p) { super(p); } + + public AllHitsRayResultCallback(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld) { super((Pointer)null); allocate(rayFromWorld, rayToWorld); } + private native void allocate(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld); + + + + public native @ByRef btVector3 m_rayFromWorld(); public native AllHitsRayResultCallback m_rayFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction + public native @ByRef btVector3 m_rayToWorld(); public native AllHitsRayResultCallback m_rayToWorld(btVector3 setter); + + public native @ByRef btAlignedObjectArray_btVector3 m_hitNormalWorld(); public native AllHitsRayResultCallback m_hitNormalWorld(btAlignedObjectArray_btVector3 setter); + public native @ByRef btAlignedObjectArray_btVector3 m_hitPointWorld(); public native AllHitsRayResultCallback m_hitPointWorld(btAlignedObjectArray_btVector3 setter); + public native @ByRef btAlignedObjectArray_btScalar m_hitFractions(); public native AllHitsRayResultCallback m_hitFractions(btAlignedObjectArray_btScalar setter); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); + } + + @NoOffset public static class LocalConvexResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LocalConvexResult(Pointer p) { super(p); } + + public LocalConvexResult(@Const btCollisionObject hitCollisionObject, + LocalShapeInfo localShapeInfo, + @Const @ByRef btVector3 hitNormalLocal, + @Const @ByRef btVector3 hitPointLocal, + @Cast("btScalar") float hitFraction) { super((Pointer)null); allocate(hitCollisionObject, localShapeInfo, hitNormalLocal, hitPointLocal, hitFraction); } + private native void allocate(@Const btCollisionObject hitCollisionObject, + LocalShapeInfo localShapeInfo, + @Const @ByRef btVector3 hitNormalLocal, + @Const @ByRef btVector3 hitPointLocal, + @Cast("btScalar") float hitFraction); + + public native @Const btCollisionObject m_hitCollisionObject(); public native LocalConvexResult m_hitCollisionObject(btCollisionObject setter); + public native LocalShapeInfo m_localShapeInfo(); public native LocalConvexResult m_localShapeInfo(LocalShapeInfo setter); + public native @ByRef btVector3 m_hitNormalLocal(); public native LocalConvexResult m_hitNormalLocal(btVector3 setter); + public native @ByRef btVector3 m_hitPointLocal(); public native LocalConvexResult m_hitPointLocal(btVector3 setter); + public native @Cast("btScalar") float m_hitFraction(); public native LocalConvexResult m_hitFraction(float setter); + } + + /**RayResultCallback is used to report new raycast results */ + @NoOffset public static class ConvexResultCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ConvexResultCallback(Pointer p) { super(p); } + + public native @Cast("btScalar") float m_closestHitFraction(); public native ConvexResultCallback m_closestHitFraction(float setter); + public native int m_collisionFilterGroup(); public native ConvexResultCallback m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native ConvexResultCallback m_collisionFilterMask(int setter); + + public native @Cast("bool") boolean hasHit(); + + public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalConvexResult convexResult, @Cast("bool") boolean normalInWorldSpace); + } + + @NoOffset public static class ClosestConvexResultCallback extends ConvexResultCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ClosestConvexResultCallback(Pointer p) { super(p); } + + public ClosestConvexResultCallback(@Const @ByRef btVector3 convexFromWorld, @Const @ByRef btVector3 convexToWorld) { super((Pointer)null); allocate(convexFromWorld, convexToWorld); } + private native void allocate(@Const @ByRef btVector3 convexFromWorld, @Const @ByRef btVector3 convexToWorld); + + public native @ByRef btVector3 m_convexFromWorld(); public native ClosestConvexResultCallback m_convexFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction + public native @ByRef btVector3 m_convexToWorld(); public native ClosestConvexResultCallback m_convexToWorld(btVector3 setter); + + public native @ByRef btVector3 m_hitNormalWorld(); public native ClosestConvexResultCallback m_hitNormalWorld(btVector3 setter); + public native @ByRef btVector3 m_hitPointWorld(); public native ClosestConvexResultCallback m_hitPointWorld(btVector3 setter); + public native @Const btCollisionObject m_hitCollisionObject(); public native ClosestConvexResultCallback m_hitCollisionObject(btCollisionObject setter); + + public native @Cast("btScalar") float addSingleResult(@ByRef LocalConvexResult convexResult, @Cast("bool") boolean normalInWorldSpace); + } + + /**ContactResultCallback is used to report contact points */ + @NoOffset public static class ContactResultCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ContactResultCallback(Pointer p) { super(p); } + + public native int m_collisionFilterGroup(); public native ContactResultCallback m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native ContactResultCallback m_collisionFilterMask(int setter); + public native @Cast("btScalar") float m_closestDistanceThreshold(); public native ContactResultCallback m_closestDistanceThreshold(float setter); + + public native @Cast("bool") boolean needsCollision(btBroadphaseProxy proxy0); + + public native @Cast("btScalar") float addSingleResult(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper colObj0Wrap, int partId0, int index0, @Const btCollisionObjectWrapper colObj1Wrap, int partId1, int index1); + } + + public native int getNumCollisionObjects(); + + /** rayTest performs a raycast on all objects in the btCollisionWorld, and calls the resultCallback + * This allows for several queries: first hit, all hits, any hit, dependent on the value returned by the callback. */ + public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); + + /** convexTest performs a swept convex cast on all objects in the btCollisionWorld, and calls the resultCallback + * This allows for several queries: first hit, all hits, any hit, dependent on the value return by the callback. */ + public native void convexSweepTest(@Const btConvexShape castShape, @Const @ByRef btTransform from, @Const @ByRef btTransform to, @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedCcdPenetration/*=btScalar(0.)*/); + public native void convexSweepTest(@Const btConvexShape castShape, @Const @ByRef btTransform from, @Const @ByRef btTransform to, @ByRef ConvexResultCallback resultCallback); + + /**contactTest performs a discrete collision test between colObj against all objects in the btCollisionWorld, and calls the resultCallback. + * it reports one or more contact points for every overlapping object (including the one with deepest penetration) */ + public native void contactTest(btCollisionObject colObj, @ByRef ContactResultCallback resultCallback); + + /**contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected. + * it reports one or more contact points (including the one with deepest penetration) */ + public native void contactPairTest(btCollisionObject colObjA, btCollisionObject colObjB, @ByRef ContactResultCallback resultCallback); + + /** rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest. + * In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape. + * This allows more customization. */ + public static native void rayTestSingle(@Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, + btCollisionObject collisionObject, + @Const btCollisionShape collisionShape, + @Const @ByRef btTransform colObjWorldTransform, + @ByRef RayResultCallback resultCallback); + + public static native void rayTestSingleInternal(@Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, + @Const btCollisionObjectWrapper collisionObjectWrap, + @ByRef RayResultCallback resultCallback); + + /** objectQuerySingle performs a collision detection query and calls the resultCallback. It is used internally by rayTest. */ + public static native void objectQuerySingle(@Const btConvexShape castShape, @Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, + btCollisionObject collisionObject, + @Const btCollisionShape collisionShape, + @Const @ByRef btTransform colObjWorldTransform, + @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedPenetration); + + public static native void objectQuerySingleInternal(@Const btConvexShape castShape, @Const @ByRef btTransform convexFromTrans, @Const @ByRef btTransform convexToTrans, + @Const btCollisionObjectWrapper colObjWrap, + @ByRef ConvexResultCallback resultCallback, @Cast("btScalar") float allowedPenetration); + + public native void addCollisionObject(btCollisionObject collisionObject, int collisionFilterGroup/*=btBroadphaseProxy::DefaultFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter*/); + public native void addCollisionObject(btCollisionObject collisionObject); + + public native void refreshBroadphaseProxy(btCollisionObject collisionObject); + + public native @Cast("btCollisionObjectArray*") @ByRef btAlignedObjectArray_btVector3 getCollisionObjectArray(); + + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native void performDiscreteCollisionDetection(); + + public native @ByRef btDispatcherInfo getDispatchInfo(); + + public native @Cast("bool") boolean getForceUpdateAllAabbs(); + public native void setForceUpdateAllAabbs(@Cast("bool") boolean forceUpdateAllAabbs); + + /**Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (Bullet/Demos/SerializeDemo) */ + public native void serialize(btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShape.java new file mode 100644 index 00000000000..e412d5f78be --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShape.java @@ -0,0 +1,97 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** The btCompoundShape allows to store multiple other btCollisionShapes + * This allows for moving concave collision objects. This is more general then the static concave btBvhTriangleMeshShape. + * It has an (optional) dynamic aabb tree to accelerate early rejection tests. + * \todo: This aabb tree can also be use to speed up ray tests on btCompoundShape, see http://code.google.com/p/bullet/issues/detail?id=25 + * Currently, removal of child shapes is only supported when disabling the aabb tree (pass 'false' in the constructor of btCompoundShape) */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCompoundShape extends btCollisionShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCompoundShape position(long position) { + return (btCompoundShape)super.position(position); + } + @Override public btCompoundShape getPointer(long i) { + return new btCompoundShape((Pointer)this).offsetAddress(i); + } + + + public btCompoundShape(@Cast("bool") boolean enableDynamicAabbTree/*=true*/, int initialChildCapacity/*=0*/) { super((Pointer)null); allocate(enableDynamicAabbTree, initialChildCapacity); } + private native void allocate(@Cast("bool") boolean enableDynamicAabbTree/*=true*/, int initialChildCapacity/*=0*/); + public btCompoundShape() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void addChildShape(@Const @ByRef btTransform localTransform, btCollisionShape shape); + + /** Remove all children shapes that contain the specified shape */ + public native void removeChildShape(btCollisionShape shape); + + public native void removeChildShapeByIndex(int childShapeindex); + + public native int getNumChildShapes(); + + public native btCollisionShape getChildShape(int index); + + public native @ByRef btTransform getChildTransform(int index); + + /**set a new transform for a child, and update internal data structures (local aabb and dynamic tree) */ + public native void updateChildTransform(int childIndex, @Const @ByRef btTransform newChildTransform, @Cast("bool") boolean shouldRecalculateLocalAabb/*=true*/); + public native void updateChildTransform(int childIndex, @Const @ByRef btTransform newChildTransform); + + public native btCompoundShapeChild getChildList(); + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /** Re-calculate the local Aabb. Is called at the end of removeChildShapes. + Use this yourself if you modify the children or their transforms. */ + public native void recalculateLocalAabb(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + public native @Cast("const char*") BytePointer getName(); + + public native btDbvt getDynamicAabbTree(); + + public native void createAabbTreeFromChildren(); + + /**computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia + * and the center of mass to the current coordinate system. "masses" points to an array of masses of the children. The resulting transform + * "principal" has to be applied inversely to all children transforms in order for the local coordinate system of the compound + * shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform + * of the collision object by the principal transform. */ + public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") FloatPointer masses, @ByRef btTransform principal, @ByRef btVector3 inertia); + public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") FloatBuffer masses, @ByRef btTransform principal, @ByRef btVector3 inertia); + public native void calculatePrincipalAxisTransform(@Cast("const btScalar*") float[] masses, @ByRef btTransform principal, @ByRef btVector3 inertia); + + public native int getUpdateRevision(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java new file mode 100644 index 00000000000..2e501d53f83 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCompoundShapeChild extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCompoundShapeChild() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundShapeChild(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundShapeChild(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCompoundShapeChild position(long position) { + return (btCompoundShapeChild)super.position(position); + } + @Override public btCompoundShapeChild getPointer(long i) { + return new btCompoundShapeChild((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransform m_transform(); public native btCompoundShapeChild m_transform(btTransform setter); + public native btCollisionShape m_childShape(); public native btCompoundShapeChild m_childShape(btCollisionShape setter); + public native int m_childShapeType(); public native btCompoundShapeChild m_childShapeType(int setter); + public native @Cast("btScalar") float m_childMargin(); public native btCompoundShapeChild m_childMargin(float setter); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChildData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChildData.java new file mode 100644 index 00000000000..5b29c028bf0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChildData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCompoundShapeChildData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCompoundShapeChildData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundShapeChildData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundShapeChildData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCompoundShapeChildData position(long position) { + return (btCompoundShapeChildData)super.position(position); + } + @Override public btCompoundShapeChildData getPointer(long i) { + return new btCompoundShapeChildData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btTransformFloatData m_transform(); public native btCompoundShapeChildData m_transform(btTransformFloatData setter); + public native btCollisionShapeData m_childShape(); public native btCompoundShapeChildData m_childShape(btCollisionShapeData setter); + public native int m_childShapeType(); public native btCompoundShapeChildData m_childShapeType(int setter); + public native float m_childMargin(); public native btCompoundShapeChildData m_childMargin(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeData.java new file mode 100644 index 00000000000..f5d389ff024 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeData.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCompoundShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCompoundShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCompoundShapeData position(long position) { + return (btCompoundShapeData)super.position(position); + } + @Override public btCompoundShapeData getPointer(long i) { + return new btCompoundShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btCompoundShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native btCompoundShapeChildData m_childShapePtr(); public native btCompoundShapeData m_childShapePtr(btCompoundShapeChildData setter); + + public native int m_numChildShapes(); public native btCompoundShapeData m_numChildShapes(int setter); + + public native float m_collisionMargin(); public native btCompoundShapeData m_collisionMargin(float setter); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConcaveShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConcaveShape.java new file mode 100644 index 00000000000..49f1b0d76d2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConcaveShape.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btConcaveShape class provides an interface for non-moving (static) concave shapes. + * It has been implemented by the btStaticPlaneShape, btBvhTriangleMeshShape and btHeightfieldTerrainShape. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConcaveShape extends btCollisionShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConcaveShape(Pointer p) { super(p); } + + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native @Cast("btScalar") float getMargin(); + public native void setMargin(@Cast("btScalar") float collisionMargin); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShape.java new file mode 100644 index 00000000000..165c5e090be --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShape.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + // for the types + +/**The btConeShape implements a cone shape primitive, centered around the origin and aligned with the Y axis. The btConeShapeX is aligned around the X axis and btConeShapeZ around the Z axis. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConeShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeShape(Pointer p) { super(p); } + + + public btConeShape(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native @Cast("btScalar") float getRadius(); + public native @Cast("btScalar") float getHeight(); + + public native void setRadius(@Cast("const btScalar") float radius); + public native void setHeight(@Cast("const btScalar") float height); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("const char*") BytePointer getName(); + + /**choose upAxis index */ + public native void setConeUpIndex(int upIndex); + + public native int getConeUpIndex(); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeData.java new file mode 100644 index 00000000000..b76913cc4b5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConeShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConeShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConeShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConeShapeData position(long position) { + return (btConeShapeData)super.position(position); + } + @Override public btConeShapeData getPointer(long i) { + return new btConeShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btConeShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native int m_upIndex(); public native btConeShapeData m_upIndex(int setter); + + public native @Cast("char") byte m_padding(int i); public native btConeShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java new file mode 100644 index 00000000000..10513ae4824 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java @@ -0,0 +1,30 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btConeShape implements a Cone shape, around the X axis */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConeShapeX extends btConeShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeShapeX(Pointer p) { super(p); } + + public btConeShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java new file mode 100644 index 00000000000..4e2456460e5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java @@ -0,0 +1,30 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btConeShapeZ implements a Cone shape, around the Z axis */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConeShapeZ extends btConeShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeShapeZ(Pointer p) { super(p); } + + public btConeShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height) { super((Pointer)null); allocate(radius, height); } + private native void allocate(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConstraintRow.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConstraintRow.java new file mode 100644 index 00000000000..08c30af6b4c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConstraintRow.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// #ifdef PFX_USE_FREE_VECTORMATH +// #else +// Don't change following order of parameters +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConstraintRow extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConstraintRow() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConstraintRow(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintRow(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConstraintRow position(long position) { + return (btConstraintRow)super.position(position); + } + @Override public btConstraintRow getPointer(long i) { + return new btConstraintRow((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_normal(int i); public native btConstraintRow m_normal(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_normal(); + public native @Cast("btScalar") float m_rhs(); public native btConstraintRow m_rhs(float setter); + public native @Cast("btScalar") float m_jacDiagInv(); public native btConstraintRow m_jacDiagInv(float setter); + public native @Cast("btScalar") float m_lowerLimit(); public native btConstraintRow m_lowerLimit(float setter); + public native @Cast("btScalar") float m_upperLimit(); public native btConstraintRow m_upperLimit(float setter); + public native @Cast("btScalar") float m_accumImpulse(); public native btConstraintRow m_accumImpulse(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShape.java new file mode 100644 index 00000000000..e97cfc744ab --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShape.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btConvexHullShape implements an implicit convex hull of an array of vertices. + * Bullet provides a general and fast collision detector for convex shapes based on GJK and EPA using localGetSupportingVertex. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexHullShape extends btPolyhedralConvexAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexHullShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexHullShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btConvexHullShape position(long position) { + return (btConvexHullShape)super.position(position); + } + @Override public btConvexHullShape getPointer(long i) { + return new btConvexHullShape((Pointer)this).offsetAddress(i); + } + + + /**this constructor optionally takes in a pointer to points. Each point is assumed to be 3 consecutive btScalar (x,y,z), the striding defines the number of bytes between each point, in memory. + * It is easier to not pass any points in the constructor, and just add one point at a time, using addPoint. + * btConvexHullShape make an internal copy of the points. */ + public btConvexHullShape(@Cast("const btScalar*") FloatPointer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } + private native void allocate(@Cast("const btScalar*") FloatPointer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); + public btConvexHullShape() { super((Pointer)null); allocate(); } + private native void allocate(); + public btConvexHullShape(@Cast("const btScalar*") FloatBuffer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } + private native void allocate(@Cast("const btScalar*") FloatBuffer points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); + public btConvexHullShape(@Cast("const btScalar*") float[] points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(points, numPoints, stride); } + private native void allocate(@Cast("const btScalar*") float[] points/*=0*/, int numPoints/*=0*/, int stride/*=sizeof(btVector3)*/); + + public native void addPoint(@Const @ByRef btVector3 point, @Cast("bool") boolean recalculateLocalAabb/*=true*/); + public native void addPoint(@Const @ByRef btVector3 point); + + public native btVector3 getUnscaledPoints(); + + /**getPoints is obsolete, please use getUnscaledPoints */ + public native @Const btVector3 getPoints(); + + public native void optimizeConvexHull(); + + public native @ByVal btVector3 getScaledPoint(int i); + + public native int getNumPoints(); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatPointer minProj, @Cast("btScalar*") @ByRef FloatPointer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatBuffer minProj, @Cast("btScalar*") @ByRef FloatBuffer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef float[] minProj, @Cast("btScalar*") @ByRef float[] maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumVertices(); + public native int getNumEdges(); + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + public native void getVertex(int i, @ByRef btVector3 vtx); + public native int getNumPlanes(); + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + /**in case we receive negative scaling */ + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShapeData.java new file mode 100644 index 00000000000..1c756c00a7d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShapeData.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexHullShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConvexHullShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexHullShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexHullShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConvexHullShapeData position(long position) { + return (btConvexHullShapeData)super.position(position); + } + @Override public btConvexHullShapeData getPointer(long i) { + return new btConvexHullShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btConvexHullShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native btVector3FloatData m_unscaledPointsFloatPtr(); public native btConvexHullShapeData m_unscaledPointsFloatPtr(btVector3FloatData setter); + public native btVector3DoubleData m_unscaledPointsDoublePtr(); public native btConvexHullShapeData m_unscaledPointsDoublePtr(btVector3DoubleData setter); + + public native int m_numUnscaledPoints(); public native btConvexHullShapeData m_numUnscaledPoints(int setter); + public native @Cast("char") byte m_padding3(int i); public native btConvexHullShapeData m_padding3(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding3(); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalAabbCachingShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalAabbCachingShape.java new file mode 100644 index 00000000000..c6720faa1c3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalAabbCachingShape.java @@ -0,0 +1,28 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btConvexInternalAabbCachingShape adds local aabb caching for convex shapes, to avoid expensive bounding box calculations */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexInternalAabbCachingShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexInternalAabbCachingShape(Pointer p) { super(p); } + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void recalcLocalAabb(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShape.java new file mode 100644 index 00000000000..da372055024 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShape.java @@ -0,0 +1,67 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btConvexInternalShape is an internal base class, shared by most convex shape implementations. + * The btConvexInternalShape uses a default collision margin set to CONVEX_DISTANCE_MARGIN. + * This collision margin used by Gjk and some other algorithms, see also btCollisionMargin.h + * Note that when creating small shapes (derived from btConvexInternalShape), + * you need to make sure to set a smaller collision margin, using the 'setMargin' API + * There is a automatic mechanism 'setSafeMargin' used by btBoxShape and btCylinderShape */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexInternalShape extends btConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexInternalShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native @Const @ByRef btVector3 getImplicitShapeDimensions(); + + /**warning: use setImplicitShapeDimensions with care + * changing a collision shape while the body is in the world is not recommended, + * it is best to remove the body from the world, then make the change, and re-add it + * alternatively flush the contact points, see documentation for 'cleanProxyFromPairs' */ + public native void setImplicitShapeDimensions(@Const @ByRef btVector3 dimensions); + + public native void setSafeMargin(@Cast("btScalar") float minDimension, @Cast("btScalar") float defaultMarginMultiplier/*=0.1f*/); + public native void setSafeMargin(@Cast("btScalar") float minDimension); + public native void setSafeMargin(@Const @ByRef btVector3 halfExtents, @Cast("btScalar") float defaultMarginMultiplier/*=0.1f*/); + public native void setSafeMargin(@Const @ByRef btVector3 halfExtents); + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void getAabbSlow(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native @Const @ByRef btVector3 getLocalScalingNV(); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + + public native @Cast("btScalar") float getMarginNV(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShapeData.java new file mode 100644 index 00000000000..e70defb2908 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShapeData.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexInternalShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConvexInternalShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexInternalShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexInternalShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConvexInternalShapeData position(long position) { + return (btConvexInternalShapeData)super.position(position); + } + @Override public btConvexInternalShapeData getPointer(long i) { + return new btConvexInternalShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btConvexInternalShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native @ByRef btVector3FloatData m_localScaling(); public native btConvexInternalShapeData m_localScaling(btVector3FloatData setter); + + public native @ByRef btVector3FloatData m_implicitShapeDimensions(); public native btConvexInternalShapeData m_implicitShapeDimensions(btVector3FloatData setter); + + public native float m_collisionMargin(); public native btConvexInternalShapeData m_collisionMargin(float setter); + + public native int m_padding(); public native btConvexInternalShapeData m_padding(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java new file mode 100644 index 00000000000..a7ae07c0555 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexPenetrationDepthSolver extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btConvexPenetrationDepthSolver() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexPenetrationDepthSolver(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java new file mode 100644 index 00000000000..e6be63cc862 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexPolyhedron extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btConvexPolyhedron() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexPolyhedron(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java new file mode 100644 index 00000000000..a26091ab48f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexShape extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btConvexShape() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexShape(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleMeshShape.java new file mode 100644 index 00000000000..e6b11e02428 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleMeshShape.java @@ -0,0 +1,58 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + // for the types + +/** The btConvexTriangleMeshShape is a convex hull of a triangle mesh, but the performance is not as good as btConvexHullShape. + * A small benefit of this class is that it uses the btStridingMeshInterface, so you can avoid the duplication of the triangle mesh data. Nevertheless, most users should use the much better performing btConvexHullShape instead. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexTriangleMeshShape extends btPolyhedralConvexAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexTriangleMeshShape(Pointer p) { super(p); } + + + public btConvexTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean calcAabb/*=true*/) { super((Pointer)null); allocate(meshInterface, calcAabb); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean calcAabb/*=true*/); + public btConvexTriangleMeshShape(btStridingMeshInterface meshInterface) { super((Pointer)null); allocate(meshInterface); } + private native void allocate(btStridingMeshInterface meshInterface); + + public native btStridingMeshInterface getMeshInterface(); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumVertices(); + public native int getNumEdges(); + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + public native void getVertex(int i, @ByRef btVector3 vtx); + public native int getNumPlanes(); + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + /**computes the exact moment of inertia and the transform from the coordinate system defined by the principal axes of the moment of inertia + * and the center of mass to the current coordinate system. A mass of 1 is assumed, for other masses just multiply the computed "inertia" + * by the mass. The resulting transform "principal" has to be applied inversely to the mesh in order for the local coordinate system of the + * shape to be centered at the center of mass and to coincide with the principal axes. This also necessitates a correction of the world transform + * of the collision object by the principal transform. This method also computes the volume of the convex mesh. */ + public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef FloatPointer volume); + public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef FloatBuffer volume); + public native void calculatePrincipalAxisTransform(@ByRef btTransform principal, @ByRef btVector3 inertia, @Cast("btScalar*") @ByRef float[] volume); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShape.java new file mode 100644 index 00000000000..83d6b8af3c8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShape.java @@ -0,0 +1,61 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** The btCylinderShape class implements a cylinder shape primitive, centered around the origin. Its central axis aligned with the Y axis. btCylinderShapeX is aligned with the X axis and btCylinderShapeZ around the Z axis. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCylinderShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCylinderShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 getHalfExtentsWithMargin(); + + public native @Const @ByRef btVector3 getHalfExtentsWithoutMargin(); + + public btCylinderShape(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } + private native void allocate(@Const @ByRef btVector3 halfExtents); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void setMargin(@Cast("btScalar") float collisionMargin); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + //use box inertia + // virtual void calculateLocalInertia(btScalar mass,btVector3& inertia) const; + + public native int getUpAxis(); + + public native @ByVal btVector3 getAnisotropicRollingFrictionDirection(); + + public native @Cast("btScalar") float getRadius(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeData.java new file mode 100644 index 00000000000..0ea4e148f84 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCylinderShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCylinderShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCylinderShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCylinderShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCylinderShapeData position(long position) { + return (btCylinderShapeData)super.position(position); + } + @Override public btCylinderShapeData getPointer(long i) { + return new btCylinderShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btCylinderShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native int m_upAxis(); public native btCylinderShapeData m_upAxis(int setter); + + public native @Cast("char") byte m_padding(int i); public native btCylinderShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java new file mode 100644 index 00000000000..e9e8b8b089a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java @@ -0,0 +1,33 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCylinderShapeX extends btCylinderShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCylinderShapeX(Pointer p) { super(p); } + + + public btCylinderShapeX(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } + private native void allocate(@Const @ByRef btVector3 halfExtents); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native @Cast("btScalar") float getRadius(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java new file mode 100644 index 00000000000..e0fade73973 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java @@ -0,0 +1,33 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCylinderShapeZ extends btCylinderShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCylinderShapeZ(Pointer p) { super(p); } + + + public btCylinderShapeZ(@Const @ByRef btVector3 halfExtents) { super((Pointer)null); allocate(halfExtents); } + private native void allocate(@Const @ByRef btVector3 halfExtents); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native @Cast("btScalar") float getRadius(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java new file mode 100644 index 00000000000..86d60b67dd9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +//class btOptimizedBvh; +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDbvt extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btDbvt() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvt(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java new file mode 100644 index 00000000000..c8bcce8f40b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java @@ -0,0 +1,100 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btDbvtBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see btDbvt). + * One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other. + * This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases btAxisSweep3 and bt32BitAxisSweep3. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDbvtBroadphase extends btBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvtBroadphase(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDbvtBroadphase(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDbvtBroadphase position(long position) { + return (btDbvtBroadphase)super.position(position); + } + @Override public btDbvtBroadphase getPointer(long i) { + return new btDbvtBroadphase((Pointer)this).offsetAddress(i); + } + + /* Config */ + /** enum btDbvtBroadphase:: */ + public static final int + DYNAMIC_SET = 0, /* Dynamic set index */ + FIXED_SET = 1, /* Fixed set index */ + STAGECOUNT = 2; /* Number of stages */ + /* Fields */ + public native @ByRef btDbvt m_sets(int i); public native btDbvtBroadphase m_sets(int i, btDbvt setter); + @MemberGetter public native btDbvt m_sets(); // Dbvt sets // Stages list + public native btOverlappingPairCache m_paircache(); public native btDbvtBroadphase m_paircache(btOverlappingPairCache setter); // Pair cache + public native @Cast("btScalar") float m_prediction(); public native btDbvtBroadphase m_prediction(float setter); // Velocity prediction + public native int m_stageCurrent(); public native btDbvtBroadphase m_stageCurrent(int setter); // Current stage + public native int m_fupdates(); public native btDbvtBroadphase m_fupdates(int setter); // % of fixed updates per frame + public native int m_dupdates(); public native btDbvtBroadphase m_dupdates(int setter); // % of dynamic updates per frame + public native int m_cupdates(); public native btDbvtBroadphase m_cupdates(int setter); // % of cleanup updates per frame + public native int m_newpairs(); public native btDbvtBroadphase m_newpairs(int setter); // Number of pairs created + public native int m_fixedleft(); public native btDbvtBroadphase m_fixedleft(int setter); // Fixed optimization left + public native @Cast("unsigned") int m_updates_call(); public native btDbvtBroadphase m_updates_call(int setter); // Number of updates call + public native @Cast("unsigned") int m_updates_done(); public native btDbvtBroadphase m_updates_done(int setter); // Number of updates done + public native @Cast("btScalar") float m_updates_ratio(); public native btDbvtBroadphase m_updates_ratio(float setter); // m_updates_done/m_updates_call + public native int m_pid(); public native btDbvtBroadphase m_pid(int setter); // Parse id + public native int m_cid(); public native btDbvtBroadphase m_cid(int setter); // Cleanup index + public native int m_gid(); public native btDbvtBroadphase m_gid(int setter); // Gen id + public native @Cast("bool") boolean m_releasepaircache(); public native btDbvtBroadphase m_releasepaircache(boolean setter); // Release pair cache on delete + public native @Cast("bool") boolean m_deferedcollide(); public native btDbvtBroadphase m_deferedcollide(boolean setter); // Defere dynamic/static collision to collide call + public native @Cast("bool") boolean m_needcleanup(); public native btDbvtBroadphase m_needcleanup(boolean setter); // Need to run cleanup? + +// #if DBVT_BP_PROFILE +// #endif + /* Methods */ + public btDbvtBroadphase(btOverlappingPairCache paircache/*=0*/) { super((Pointer)null); allocate(paircache); } + private native void allocate(btOverlappingPairCache paircache/*=0*/); + public btDbvtBroadphase() { super((Pointer)null); allocate(); } + private native void allocate(); + public native void collide(btDispatcher dispatcher); + public native void optimize(); + + /* btBroadphaseInterface Implementation */ + public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); + public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); + public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); + + public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + public native void calculateOverlappingPairs(btDispatcher dispatcher); + public native btOverlappingPairCache getOverlappingPairCache(); + public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + public native void printStats(); + + /**reset broadphase internal structures, to ensure determinism/reproducability */ + public native void resetPool(btDispatcher dispatcher); + + public native void performDeferredRemoval(btDispatcher dispatcher); + + public native void setVelocityPrediction(@Cast("btScalar") float prediction); + public native @Cast("btScalar") float getVelocityPrediction(); + + /**this setAabbForceUpdate is similar to setAabb but always forces the aabb update. + * it is not part of the btBroadphaseInterface but specific to btDbvtBroadphase. + * it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see + * http://code.google.com/p/bullet/issues/detail?id=223 */ + public native void setAabbForceUpdate(btBroadphaseProxy absproxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher arg3); + + public static native void benchmark(btBroadphaseInterface arg0); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConfiguration.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConfiguration.java new file mode 100644 index 00000000000..c7ce640e14e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConfiguration.java @@ -0,0 +1,60 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btCollisionConfiguration allows to configure Bullet collision detection + * stack allocator, pool memory allocators + * \todo: describe the meaning */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDefaultCollisionConfiguration extends btCollisionConfiguration { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultCollisionConfiguration(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultCollisionConfiguration(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultCollisionConfiguration position(long position) { + return (btDefaultCollisionConfiguration)super.position(position); + } + @Override public btDefaultCollisionConfiguration getPointer(long i) { + return new btDefaultCollisionConfiguration((Pointer)this).offsetAddress(i); + } + + public btDefaultCollisionConfiguration(@Const @ByRef(nullValue = "btDefaultCollisionConstructionInfo()") btDefaultCollisionConstructionInfo constructionInfo) { super((Pointer)null); allocate(constructionInfo); } + private native void allocate(@Const @ByRef(nullValue = "btDefaultCollisionConstructionInfo()") btDefaultCollisionConstructionInfo constructionInfo); + public btDefaultCollisionConfiguration() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**memory pools */ + public native btPoolAllocator getPersistentManifoldPool(); + + public native btPoolAllocator getCollisionAlgorithmPool(); + + public native btCollisionAlgorithmCreateFunc getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1); + + public native btCollisionAlgorithmCreateFunc getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1); + + /**Use this method to allow to generate multiple contact points between at once, between two objects using the generic convex-convex algorithm. + * By default, this feature is disabled for best performance. + * @param numPerturbationIterations controls the number of collision queries. Set it to zero to disable the feature. + * @param minimumPointsPerturbationThreshold is the minimum number of points in the contact cache, above which the feature is disabled + * 3 is a good value for both params, if you want to enable the feature. This is because the default contact cache contains a maximum of 4 points, and one collision query at the unperturbed orientation is performed first. + * See Bullet/Demos/CollisionDemo for an example how this feature gathers multiple points. + * \todo we could add a per-object setting of those parameters, for level-of-detail collision detection. */ + public native void setConvexConvexMultipointIterations(int numPerturbationIterations/*=3*/, int minimumPointsPerturbationThreshold/*=3*/); + public native void setConvexConvexMultipointIterations(); + + public native void setPlaneConvexMultipointIterations(int numPerturbationIterations/*=3*/, int minimumPointsPerturbationThreshold/*=3*/); + public native void setPlaneConvexMultipointIterations(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConstructionInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConstructionInfo.java new file mode 100644 index 00000000000..94e676c5b95 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConstructionInfo.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDefaultCollisionConstructionInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultCollisionConstructionInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultCollisionConstructionInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultCollisionConstructionInfo position(long position) { + return (btDefaultCollisionConstructionInfo)super.position(position); + } + @Override public btDefaultCollisionConstructionInfo getPointer(long i) { + return new btDefaultCollisionConstructionInfo((Pointer)this).offsetAddress(i); + } + + public native btPoolAllocator m_persistentManifoldPool(); public native btDefaultCollisionConstructionInfo m_persistentManifoldPool(btPoolAllocator setter); + public native btPoolAllocator m_collisionAlgorithmPool(); public native btDefaultCollisionConstructionInfo m_collisionAlgorithmPool(btPoolAllocator setter); + public native int m_defaultMaxPersistentManifoldPoolSize(); public native btDefaultCollisionConstructionInfo m_defaultMaxPersistentManifoldPoolSize(int setter); + public native int m_defaultMaxCollisionAlgorithmPoolSize(); public native btDefaultCollisionConstructionInfo m_defaultMaxCollisionAlgorithmPoolSize(int setter); + public native int m_customCollisionAlgorithmMaxElementSize(); public native btDefaultCollisionConstructionInfo m_customCollisionAlgorithmMaxElementSize(int setter); + public native int m_useEpaPenetrationAlgorithm(); public native btDefaultCollisionConstructionInfo m_useEpaPenetrationAlgorithm(int setter); + + public btDefaultCollisionConstructionInfo() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDiscreteCollisionDetectorInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDiscreteCollisionDetectorInterface.java new file mode 100644 index 00000000000..f9f8409a6b2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDiscreteCollisionDetectorInterface.java @@ -0,0 +1,67 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** This interface is made to be used by an iterative approach to do TimeOfImpact calculations + * This interface allows to query for closest points and penetration depth between two (convex) objects + * the closest point is on the second object (B), and the normal points from the surface on B towards A. + * distance is between closest points on B and closest point on A. So you can calculate closest point on A + * by taking closestPointInA = closestPointInB + m_distance * m_normalOnSurfaceB */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDiscreteCollisionDetectorInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDiscreteCollisionDetectorInterface(Pointer p) { super(p); } + + public static class Result extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Result(Pointer p) { super(p); } + + + /**setShapeIdentifiersA/B provides experimental support for per-triangle material / custom material combiner */ + public native void setShapeIdentifiersA(int partId0, int index0); + public native void setShapeIdentifiersB(int partId1, int index1); + public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); + } + + @NoOffset public static class ClosestPointInput extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ClosestPointInput(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public ClosestPointInput(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public ClosestPointInput position(long position) { + return (ClosestPointInput)super.position(position); + } + @Override public ClosestPointInput getPointer(long i) { + return new ClosestPointInput((Pointer)this).offsetAddress(i); + } + + public ClosestPointInput() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @ByRef btTransform m_transformA(); public native ClosestPointInput m_transformA(btTransform setter); + public native @ByRef btTransform m_transformB(); public native ClosestPointInput m_transformB(btTransform setter); + public native @Cast("btScalar") float m_maximumDistanceSquared(); public native ClosestPointInput m_maximumDistanceSquared(float setter); + } + + // + // give either closest points (distance > 0) or penetration (distance) + // the normal always points from B towards A + // + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw, @Cast("bool") boolean swapResults/*=false*/); + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcher.java new file mode 100644 index 00000000000..429cbe5867c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcher.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btDispatcher interface class can be used in combination with broadphase to dispatch calculations for overlapping pairs. + * For example for pairwise collision detection, calculating contact points stored in btPersistentManifold or user callbacks (game logic). */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDispatcher extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDispatcher(Pointer p) { super(p); } + + + public native btCollisionAlgorithm findAlgorithm(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btPersistentManifold sharedManifold, @Cast("ebtDispatcherQueryType") int queryType); + + public native btPersistentManifold getNewManifold(@Const btCollisionObject b0, @Const btCollisionObject b1); + + public native void releaseManifold(btPersistentManifold manifold); + + public native void clearManifold(btPersistentManifold manifold); + + public native @Cast("bool") boolean needsCollision(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native @Cast("bool") boolean needsResponse(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native void dispatchAllCollisionPairs(btOverlappingPairCache pairCache, @Const @ByRef btDispatcherInfo dispatchInfo, btDispatcher dispatcher); + + public native int getNumManifolds(); + + public native btPersistentManifold getManifoldByIndexInternal(int index); + + public native @Cast("btPersistentManifold**") PointerPointer getInternalManifoldPointer(); + + public native btPoolAllocator getInternalManifoldPool(); + + public native Pointer allocateCollisionAlgorithm(int size); + + public native void freeCollisionAlgorithm(Pointer ptr); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java new file mode 100644 index 00000000000..e44f62f85c0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDispatcherInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDispatcherInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDispatcherInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDispatcherInfo position(long position) { + return (btDispatcherInfo)super.position(position); + } + @Override public btDispatcherInfo getPointer(long i) { + return new btDispatcherInfo((Pointer)this).offsetAddress(i); + } + + /** enum btDispatcherInfo::DispatchFunc */ + public static final int + DISPATCH_DISCRETE = 1, + DISPATCH_CONTINUOUS = 2; + public btDispatcherInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float m_timeStep(); public native btDispatcherInfo m_timeStep(float setter); + public native int m_stepCount(); public native btDispatcherInfo m_stepCount(int setter); + public native int m_dispatchFunc(); public native btDispatcherInfo m_dispatchFunc(int setter); + public native @Cast("btScalar") float m_timeOfImpact(); public native btDispatcherInfo m_timeOfImpact(float setter); + public native @Cast("bool") boolean m_useContinuous(); public native btDispatcherInfo m_useContinuous(boolean setter); + public native btIDebugDraw m_debugDraw(); public native btDispatcherInfo m_debugDraw(btIDebugDraw setter); + public native @Cast("bool") boolean m_enableSatConvex(); public native btDispatcherInfo m_enableSatConvex(boolean setter); + public native @Cast("bool") boolean m_enableSPU(); public native btDispatcherInfo m_enableSPU(boolean setter); + public native @Cast("bool") boolean m_useEpa(); public native btDispatcherInfo m_useEpa(boolean setter); + public native @Cast("btScalar") float m_allowedCcdPenetration(); public native btDispatcherInfo m_allowedCcdPenetration(float setter); + public native @Cast("bool") boolean m_useConvexConservativeDistanceUtil(); public native btDispatcherInfo m_useConvexConservativeDistanceUtil(boolean setter); + public native @Cast("btScalar") float m_convexConservativeDistanceThreshold(); public native btDispatcherInfo m_convexConservativeDistanceThreshold(float setter); + public native @Cast("bool") boolean m_deterministicOverlappingPairs(); public native btDispatcherInfo m_deterministicOverlappingPairs(boolean setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java new file mode 100644 index 00000000000..2f97f475293 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** The btEmptyShape is a collision shape without actual collision detection shape, so most users should ignore this class. + * It can be replaced by another shape during runtime, but the inertia tensor should be recomputed. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btEmptyShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btEmptyShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btEmptyShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btEmptyShape position(long position) { + return (btEmptyShape)super.position(position); + } + @Override public btEmptyShape getPointer(long i) { + return new btEmptyShape((Pointer)this).offsetAddress(i); + } + + + public btEmptyShape() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("const char*") BytePointer getName(); + + public native void processAllTriangles(btTriangleCallback arg0, @Const @ByRef btVector3 arg1, @Const @ByRef btVector3 arg2); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java new file mode 100644 index 00000000000..51b8ec8b8e0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java @@ -0,0 +1,71 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com */ + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btHashedOverlappingPairCache extends btOverlappingPairCache { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashedOverlappingPairCache(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHashedOverlappingPairCache(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btHashedOverlappingPairCache position(long position) { + return (btHashedOverlappingPairCache)super.position(position); + } + @Override public btHashedOverlappingPairCache getPointer(long i) { + return new btHashedOverlappingPairCache((Pointer)this).offsetAddress(i); + } + + + public btHashedOverlappingPairCache() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); + + public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + // Add a pair and return the new pair. If the pair already exists, + // no new pair is created and the old one is returned. + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); + + public native void processAllOverlappingPairs(btOverlapCallback callback, btDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); + + public native btBroadphasePair getOverlappingPairArrayPtr(); + + + + + + public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); + + public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native int GetCount(); + // btBroadphasePair* GetPairs() { return m_pairs; } + + public native btOverlapFilterCallback getOverlapFilterCallback(); + + public native void setOverlapFilterCallback(btOverlapFilterCallback callback); + + public native int getNumOverlappingPairs(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java new file mode 100644 index 00000000000..903a74df0b7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btIndexedMesh indexes a single vertex and index array. Multiple btIndexedMesh objects can be passed into a btTriangleIndexVertexArray using addIndexedMesh. + * Instead of the number of indices, we pass the number of triangles. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btIndexedMesh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIndexedMesh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btIndexedMesh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btIndexedMesh position(long position) { + return (btIndexedMesh)super.position(position); + } + @Override public btIndexedMesh getPointer(long i) { + return new btIndexedMesh((Pointer)this).offsetAddress(i); + } + + + public native int m_numTriangles(); public native btIndexedMesh m_numTriangles(int setter); + public native @Cast("const unsigned char*") BytePointer m_triangleIndexBase(); public native btIndexedMesh m_triangleIndexBase(BytePointer setter); + // Size in byte of the indices for one triangle (3*sizeof(index_type) if the indices are tightly packed) + public native int m_triangleIndexStride(); public native btIndexedMesh m_triangleIndexStride(int setter); + public native int m_numVertices(); public native btIndexedMesh m_numVertices(int setter); + public native @Cast("const unsigned char*") BytePointer m_vertexBase(); public native btIndexedMesh m_vertexBase(BytePointer setter); + // Size of a vertex, in bytes + public native int m_vertexStride(); public native btIndexedMesh m_vertexStride(int setter); + + // The index type is set when adding an indexed mesh to the + // btTriangleIndexVertexArray, do not set it manually + public native @Cast("PHY_ScalarType") int m_indexType(); public native btIndexedMesh m_indexType(int setter); + + // The vertex type has a default type similar to Bullet's precision mode (float or double) + // but can be set manually if you for example run Bullet with double precision but have + // mesh data in single precision.. + public native @Cast("PHY_ScalarType") int m_vertexType(); public native btIndexedMesh m_vertexType(int setter); + + public btIndexedMesh() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIntIndexData.java new file mode 100644 index 00000000000..c9021563f72 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIntIndexData.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btIntIndexData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btIntIndexData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btIntIndexData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIntIndexData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btIntIndexData position(long position) { + return (btIntIndexData)super.position(position); + } + @Override public btIntIndexData getPointer(long i) { + return new btIntIndexData((Pointer)this).offsetAddress(i); + } + + public native int m_value(); public native btIntIndexData m_value(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btInternalTriangleIndexCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btInternalTriangleIndexCallback.java new file mode 100644 index 00000000000..9e6907832bc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btInternalTriangleIndexCallback.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btInternalTriangleIndexCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btInternalTriangleIndexCallback(Pointer p) { super(p); } + + public native void internalProcessTriangleIndex(btVector3 triangle, int partId, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldPoint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldPoint.java new file mode 100644 index 00000000000..72ac49fad56 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldPoint.java @@ -0,0 +1,95 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** ManifoldContactPoint collects and maintains persistent contactpoints. + * used to improve stability and performance of rigidbody dynamics response. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btManifoldPoint extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btManifoldPoint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btManifoldPoint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btManifoldPoint position(long position) { + return (btManifoldPoint)super.position(position); + } + @Override public btManifoldPoint getPointer(long i) { + return new btManifoldPoint((Pointer)this).offsetAddress(i); + } + + public btManifoldPoint() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btManifoldPoint(@Const @ByRef btVector3 pointA, @Const @ByRef btVector3 pointB, + @Const @ByRef btVector3 normal, + @Cast("btScalar") float distance) { super((Pointer)null); allocate(pointA, pointB, normal, distance); } + private native void allocate(@Const @ByRef btVector3 pointA, @Const @ByRef btVector3 pointB, + @Const @ByRef btVector3 normal, + @Cast("btScalar") float distance); + + public native @ByRef btVector3 m_localPointA(); public native btManifoldPoint m_localPointA(btVector3 setter); + public native @ByRef btVector3 m_localPointB(); public native btManifoldPoint m_localPointB(btVector3 setter); + public native @ByRef btVector3 m_positionWorldOnB(); public native btManifoldPoint m_positionWorldOnB(btVector3 setter); + /**m_positionWorldOnA is redundant information, see getPositionWorldOnA(), but for clarity */ + public native @ByRef btVector3 m_positionWorldOnA(); public native btManifoldPoint m_positionWorldOnA(btVector3 setter); + public native @ByRef btVector3 m_normalWorldOnB(); public native btManifoldPoint m_normalWorldOnB(btVector3 setter); + + public native @Cast("btScalar") float m_distance1(); public native btManifoldPoint m_distance1(float setter); + public native @Cast("btScalar") float m_combinedFriction(); public native btManifoldPoint m_combinedFriction(float setter); + public native @Cast("btScalar") float m_combinedRollingFriction(); public native btManifoldPoint m_combinedRollingFriction(float setter); //torsional friction orthogonal to contact normal, useful to make spheres stop rolling forever + public native @Cast("btScalar") float m_combinedSpinningFriction(); public native btManifoldPoint m_combinedSpinningFriction(float setter); //torsional friction around contact normal, useful for grasping objects + public native @Cast("btScalar") float m_combinedRestitution(); public native btManifoldPoint m_combinedRestitution(float setter); + + //BP mod, store contact triangles. + public native int m_partId0(); public native btManifoldPoint m_partId0(int setter); + public native int m_partId1(); public native btManifoldPoint m_partId1(int setter); + public native int m_index0(); public native btManifoldPoint m_index0(int setter); + public native int m_index1(); public native btManifoldPoint m_index1(int setter); + + public native Pointer m_userPersistentData(); public native btManifoldPoint m_userPersistentData(Pointer setter); + //bool m_lateralFrictionInitialized; + public native int m_contactPointFlags(); public native btManifoldPoint m_contactPointFlags(int setter); + + public native @Cast("btScalar") float m_appliedImpulse(); public native btManifoldPoint m_appliedImpulse(float setter); + public native @Cast("btScalar") float m_prevRHS(); public native btManifoldPoint m_prevRHS(float setter); + public native @Cast("btScalar") float m_appliedImpulseLateral1(); public native btManifoldPoint m_appliedImpulseLateral1(float setter); + public native @Cast("btScalar") float m_appliedImpulseLateral2(); public native btManifoldPoint m_appliedImpulseLateral2(float setter); + public native @Cast("btScalar") float m_contactMotion1(); public native btManifoldPoint m_contactMotion1(float setter); + public native @Cast("btScalar") float m_contactMotion2(); public native btManifoldPoint m_contactMotion2(float setter); + public native @Cast("btScalar") float m_contactCFM(); public native btManifoldPoint m_contactCFM(float setter); + public native @Cast("btScalar") float m_combinedContactStiffness1(); public native btManifoldPoint m_combinedContactStiffness1(float setter); + public native @Cast("btScalar") float m_contactERP(); public native btManifoldPoint m_contactERP(float setter); + public native @Cast("btScalar") float m_combinedContactDamping1(); public native btManifoldPoint m_combinedContactDamping1(float setter); + + public native @Cast("btScalar") float m_frictionCFM(); public native btManifoldPoint m_frictionCFM(float setter); + + public native int m_lifeTime(); public native btManifoldPoint m_lifeTime(int setter); //lifetime of the contactpoint in frames + + public native @ByRef btVector3 m_lateralFrictionDir1(); public native btManifoldPoint m_lateralFrictionDir1(btVector3 setter); + public native @ByRef btVector3 m_lateralFrictionDir2(); public native btManifoldPoint m_lateralFrictionDir2(btVector3 setter); + + public native @Cast("btScalar") float getDistance(); + public native int getLifeTime(); + + public native @Const @ByRef btVector3 getPositionWorldOnA(); + + public native @Const @ByRef btVector3 getPositionWorldOnB(); + + public native void setDistance(@Cast("btScalar") float dist); + + /**this returns the most recent applied impulse, to satisfy contact constraints by the constraint solver */ + public native @Cast("btScalar") float getAppliedImpulse(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldResult.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldResult.java new file mode 100644 index 00000000000..0a39b5db75e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldResult.java @@ -0,0 +1,69 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btManifoldResult is a helper class to manage contact results. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btManifoldResult extends btDiscreteCollisionDetectorInterface.Result { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btManifoldResult(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btManifoldResult(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btManifoldResult position(long position) { + return (btManifoldResult)super.position(position); + } + @Override public btManifoldResult getPointer(long i) { + return new btManifoldResult((Pointer)this).offsetAddress(i); + } + + public btManifoldResult() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btManifoldResult(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap) { super((Pointer)null); allocate(body0Wrap, body1Wrap); } + private native void allocate(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + + public native void setPersistentManifold(btPersistentManifold manifoldPtr); + public native btPersistentManifold getPersistentManifold(); + + public native void setShapeIdentifiersA(int partId0, int index0); + + public native void setShapeIdentifiersB(int partId1, int index1); + + public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); + + public native void refreshContactPoints(); + + public native @Const btCollisionObjectWrapper getBody0Wrap(); + public native @Const btCollisionObjectWrapper getBody1Wrap(); + + public native void setBody0Wrap(@Const btCollisionObjectWrapper obj0Wrap); + + public native void setBody1Wrap(@Const btCollisionObjectWrapper obj1Wrap); + + public native @Const btCollisionObject getBody0Internal(); + + public native @Const btCollisionObject getBody1Internal(); + + public native @Cast("btScalar") float m_closestPointDistanceThreshold(); public native btManifoldResult m_closestPointDistanceThreshold(float setter); + + /** in the future we can let the user override the methods to combine restitution and friction */ + public static native @Cast("btScalar") float calculateCombinedRestitution(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedRollingFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedSpinningFriction(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedContactDamping(@Const btCollisionObject body0, @Const btCollisionObject body1); + public static native @Cast("btScalar") float calculateCombinedContactStiffness(@Const btCollisionObject body0, @Const btCollisionObject body1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMeshPartData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMeshPartData.java new file mode 100644 index 00000000000..18a80238dd0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMeshPartData.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMeshPartData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMeshPartData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMeshPartData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMeshPartData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMeshPartData position(long position) { + return (btMeshPartData)super.position(position); + } + @Override public btMeshPartData getPointer(long i) { + return new btMeshPartData((Pointer)this).offsetAddress(i); + } + + public native btVector3FloatData m_vertices3f(); public native btMeshPartData m_vertices3f(btVector3FloatData setter); + public native btVector3DoubleData m_vertices3d(); public native btMeshPartData m_vertices3d(btVector3DoubleData setter); + + public native btIntIndexData m_indices32(); public native btMeshPartData m_indices32(btIntIndexData setter); + public native btShortIntIndexTripletData m_3indices16(); public native btMeshPartData m_3indices16(btShortIntIndexTripletData setter); + public native btCharIndexTripletData m_3indices8(); public native btMeshPartData m_3indices8(btCharIndexTripletData setter); + + public native btShortIntIndexData m_indices16(); public native btMeshPartData m_indices16(btShortIntIndexData setter);//backwards compatibility + + public native int m_numTriangles(); public native btMeshPartData m_numTriangles(int setter);//length of m_indices = m_numTriangles + public native int m_numVertices(); public native btMeshPartData m_numVertices(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java new file mode 100644 index 00000000000..5748291e1ef --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btMultiSphereShape represents the convex hull of a collection of spheres. You can create special capsules or other smooth volumes. + * It is possible to animate the spheres for deformation, but call 'recalcLocalAabb' after changing any sphere position/radius */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMultiSphereShape extends btConvexInternalAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiSphereShape(Pointer p) { super(p); } + + + public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") FloatPointer radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } + private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") FloatPointer radi, int numSpheres); + public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") FloatBuffer radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } + private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") FloatBuffer radi, int numSpheres); + public btMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") float[] radi, int numSpheres) { super((Pointer)null); allocate(positions, radi, numSpheres); } + private native void allocate(@Const btVector3 positions, @Cast("const btScalar*") float[] radi, int numSpheres); + + /**CollisionShape Interface */ + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + /** btConvexShape Interface */ + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native int getSphereCount(); + + public native @Const @ByRef btVector3 getSpherePosition(int index); + + public native @Cast("btScalar") float getSphereRadius(int index); + + public native @Cast("const char*") BytePointer getName(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java new file mode 100644 index 00000000000..408356de9a2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMultiSphereShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiSphereShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiSphereShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiSphereShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiSphereShapeData position(long position) { + return (btMultiSphereShapeData)super.position(position); + } + @Override public btMultiSphereShapeData getPointer(long i) { + return new btMultiSphereShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btConvexInternalShapeData m_convexInternalShapeData(); public native btMultiSphereShapeData m_convexInternalShapeData(btConvexInternalShapeData setter); + + public native btPositionAndRadius m_localPositionArrayPtr(); public native btMultiSphereShapeData m_localPositionArrayPtr(btPositionAndRadius setter); + public native int m_localPositionArraySize(); public native btMultiSphereShapeData m_localPositionArraySize(int setter); + public native @Cast("char") byte m_padding(int i); public native btMultiSphereShapeData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNearCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNearCallback.java new file mode 100644 index 00000000000..d3fc7a375c6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNearCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +/**user can override this nearcallback for collision filtering and more finegrained control over collision detection */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btNearCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btNearCallback(Pointer p) { super(p); } + protected btNearCallback() { allocate(); } + private native void allocate(); + public native void call(@ByRef btBroadphasePair collisionPair, @ByRef btCollisionDispatcher dispatcher, @Const @ByRef btDispatcherInfo dispatchInfo); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java new file mode 100644 index 00000000000..28883f108d4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btNodeOverlapCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btNodeOverlapCallback(Pointer p) { super(p); } + + + public native void processNode(int subPart, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java new file mode 100644 index 00000000000..4932bf1ef00 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java @@ -0,0 +1,63 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btNullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btNullPairCache extends btOverlappingPairCache { + static { Loader.load(); } + /** Default native constructor. */ + public btNullPairCache() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btNullPairCache(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btNullPairCache(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btNullPairCache position(long position) { + return (btNullPairCache)super.position(position); + } + @Override public btNullPairCache getPointer(long i) { + return new btNullPairCache((Pointer)this).offsetAddress(i); + } + + public native btBroadphasePair getOverlappingPairArrayPtr(); + + + public native void cleanOverlappingPair(@ByRef btBroadphasePair arg0, btDispatcher arg1); + + public native int getNumOverlappingPairs(); + + public native void cleanProxyFromPairs(btBroadphaseProxy arg0, btDispatcher arg1); + + public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy arg0, btBroadphaseProxy arg1); + public native btOverlapFilterCallback getOverlapFilterCallback(); + public native void setOverlapFilterCallback(btOverlapFilterCallback arg0); + + public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher arg1); + + public native btBroadphasePair findPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + public native void setInternalGhostPairCallback(btOverlappingPairCallback arg0); + + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1); + + public native Pointer removeOverlappingPair(btBroadphaseProxy arg0, btBroadphaseProxy arg1, btDispatcher arg2); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy arg0, btDispatcher arg1); + + public native void sortOverlappingPairs(btDispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java new file mode 100644 index 00000000000..21204079fe6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btOptimizedBvh extends the btQuantizedBvh to create AABB tree for triangle meshes, through the btStridingMeshInterface. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btOptimizedBvh extends btQuantizedBvh { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOptimizedBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btOptimizedBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btOptimizedBvh position(long position) { + return (btOptimizedBvh)super.position(position); + } + @Override public btOptimizedBvh getPointer(long i) { + return new btOptimizedBvh((Pointer)this).offsetAddress(i); + } + + public btOptimizedBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void build(btStridingMeshInterface triangles, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); + + public native void refit(btStridingMeshInterface triangles, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void refitPartial(btStridingMeshInterface triangles, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void updateBvhNodes(btStridingMeshInterface meshInterface, int firstNode, int endNode, int index); + + /** Data buffer MUST be 16 byte aligned */ + public native @Cast("bool") boolean serializeInPlace(Pointer o_alignedDataBuffer, @Cast("unsigned") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + /**deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' */ + public static native btOptimizedBvh deSerializeInPlace(Pointer i_alignedDataBuffer, @Cast("unsigned int") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java new file mode 100644 index 00000000000..e304555cba2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btOptimizedBvhNode contains both internal and leaf node information. + * Total node size is 44 bytes / node. You can use the compressed version of 16 bytes. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btOptimizedBvhNode extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btOptimizedBvhNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btOptimizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOptimizedBvhNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btOptimizedBvhNode position(long position) { + return (btOptimizedBvhNode)super.position(position); + } + @Override public btOptimizedBvhNode getPointer(long i) { + return new btOptimizedBvhNode((Pointer)this).offsetAddress(i); + } + + + //32 bytes + public native @ByRef btVector3 m_aabbMinOrg(); public native btOptimizedBvhNode m_aabbMinOrg(btVector3 setter); + public native @ByRef btVector3 m_aabbMaxOrg(); public native btOptimizedBvhNode m_aabbMaxOrg(btVector3 setter); + + //4 + public native int m_escapeIndex(); public native btOptimizedBvhNode m_escapeIndex(int setter); + + //8 + //for child nodes + public native int m_subPart(); public native btOptimizedBvhNode m_subPart(int setter); + public native int m_triangleIndex(); public native btOptimizedBvhNode m_triangleIndex(int setter); + + //pad the size to 64 bytes + public native @Cast("char") byte m_padding(int i); public native btOptimizedBvhNode m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java new file mode 100644 index 00000000000..e4f8ad98a44 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btOptimizedBvhNodeDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btOptimizedBvhNodeDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btOptimizedBvhNodeDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOptimizedBvhNodeDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btOptimizedBvhNodeDoubleData position(long position) { + return (btOptimizedBvhNodeDoubleData)super.position(position); + } + @Override public btOptimizedBvhNodeDoubleData getPointer(long i) { + return new btOptimizedBvhNodeDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3DoubleData m_aabbMinOrg(); public native btOptimizedBvhNodeDoubleData m_aabbMinOrg(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_aabbMaxOrg(); public native btOptimizedBvhNodeDoubleData m_aabbMaxOrg(btVector3DoubleData setter); + public native int m_escapeIndex(); public native btOptimizedBvhNodeDoubleData m_escapeIndex(int setter); + public native int m_subPart(); public native btOptimizedBvhNodeDoubleData m_subPart(int setter); + public native int m_triangleIndex(); public native btOptimizedBvhNodeDoubleData m_triangleIndex(int setter); + public native @Cast("char") byte m_pad(int i); public native btOptimizedBvhNodeDoubleData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeFloatData.java new file mode 100644 index 00000000000..116c2484c04 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeFloatData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btOptimizedBvhNodeFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btOptimizedBvhNodeFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btOptimizedBvhNodeFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOptimizedBvhNodeFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btOptimizedBvhNodeFloatData position(long position) { + return (btOptimizedBvhNodeFloatData)super.position(position); + } + @Override public btOptimizedBvhNodeFloatData getPointer(long i) { + return new btOptimizedBvhNodeFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_aabbMinOrg(); public native btOptimizedBvhNodeFloatData m_aabbMinOrg(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_aabbMaxOrg(); public native btOptimizedBvhNodeFloatData m_aabbMaxOrg(btVector3FloatData setter); + public native int m_escapeIndex(); public native btOptimizedBvhNodeFloatData m_escapeIndex(int setter); + public native int m_subPart(); public native btOptimizedBvhNodeFloatData m_subPart(int setter); + public native int m_triangleIndex(); public native btOptimizedBvhNodeFloatData m_triangleIndex(int setter); + public native @Cast("char") byte m_pad(int i); public native btOptimizedBvhNodeFloatData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapCallback.java new file mode 100644 index 00000000000..f4785d06802 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btOverlapCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOverlapCallback(Pointer p) { super(p); } + + //return true for deletion of the pair + public native @Cast("bool") boolean processOverlap(@ByRef btBroadphasePair pair); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapFilterCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapFilterCallback.java new file mode 100644 index 00000000000..0cfb2441a76 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapFilterCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btOverlapFilterCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOverlapFilterCallback(Pointer p) { super(p); } + + // return true when pairs need collision + public native @Cast("bool") boolean needBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java new file mode 100644 index 00000000000..5f53ea6ec51 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btOverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the btBroadphaseInterface broadphases. + * The btHashedOverlappingPairCache and btSortedOverlappingPairCache classes are two implementations. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btOverlappingPairCache extends btOverlappingPairCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOverlappingPairCache(Pointer p) { super(p); } + // this is needed so we can get to the derived class destructor + + public native btBroadphasePair getOverlappingPairArrayPtr(); + + + + public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); + + public native int getNumOverlappingPairs(); + public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + public native btOverlapFilterCallback getOverlapFilterCallback(); + public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native void setOverlapFilterCallback(btOverlapFilterCallback callback); + + public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); + + public native void processAllOverlappingPairs(btOverlapCallback callback, btDispatcher dispatcher, @Const @ByRef btDispatcherInfo arg2); + public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + public native void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback); + + public native void sortOverlappingPairs(btDispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCallback.java new file mode 100644 index 00000000000..271e01a2d25 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCallback.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btOverlappingPairCallback class is an additional optional broadphase user callback for adding/removing overlapping pairs, similar interface to btOverlappingPairCache. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btOverlappingPairCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btOverlappingPairCallback(Pointer p) { super(p); } + + + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy0, btDispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java new file mode 100644 index 00000000000..a2e1bba8fc9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java @@ -0,0 +1,22 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPersistentManifold extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btPersistentManifold() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPersistentManifold(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexAabbCachingShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexAabbCachingShape.java new file mode 100644 index 00000000000..0ea0f7c466f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexAabbCachingShape.java @@ -0,0 +1,30 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btPolyhedralConvexAabbCachingShape adds aabb caching to the btPolyhedralConvexShape */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPolyhedralConvexAabbCachingShape extends btPolyhedralConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPolyhedralConvexAabbCachingShape(Pointer p) { super(p); } + + public native void getNonvirtualAabb(@Const @ByRef btTransform trans, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax, @Cast("btScalar") float margin); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void recalcLocalAabb(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexShape.java new file mode 100644 index 00000000000..bd16f2e3142 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexShape.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btPolyhedralConvexShape is an internal interface class for polyhedral convex shapes. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPolyhedralConvexShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPolyhedralConvexShape(Pointer p) { super(p); } + + + /**optional method mainly used to generate multiple contact points by clipping polyhedral features (faces/edges) + * experimental/work-in-progress */ + public native @Cast("bool") boolean initializePolyhedralFeatures(int shiftVerticesByMargin/*=0*/); + public native @Cast("bool") boolean initializePolyhedralFeatures(); + + public native void setPolyhedralFeatures(@ByRef btConvexPolyhedron polyhedron); + + public native @Const btConvexPolyhedron getConvexPolyhedron(); + + //brute force implementations + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native int getNumVertices(); + public native int getNumEdges(); + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + public native void getVertex(int i, @ByRef btVector3 vtx); + public native int getNumPlanes(); + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + // virtual int getIndex(int i) const = 0 ; + + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoolAllocator.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoolAllocator.java new file mode 100644 index 00000000000..0bf580c64ba --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoolAllocator.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPoolAllocator extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btPoolAllocator() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoolAllocator(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPositionAndRadius.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPositionAndRadius.java new file mode 100644 index 00000000000..b41afd2dd14 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPositionAndRadius.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPositionAndRadius extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPositionAndRadius() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPositionAndRadius(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPositionAndRadius(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPositionAndRadius position(long position) { + return (btPositionAndRadius)super.position(position); + } + @Override public btPositionAndRadius getPointer(long i) { + return new btPositionAndRadius((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_pos(); public native btPositionAndRadius m_pos(btVector3FloatData setter); + public native float m_radius(); public native btPositionAndRadius m_radius(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java new file mode 100644 index 00000000000..0296199aa56 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java @@ -0,0 +1,100 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btQuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU. + * It is used by the btBvhTriangleMeshShape as midphase. + * It is recommended to use quantization for better performance and lower memory requirements. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btQuantizedBvh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btQuantizedBvh position(long position) { + return (btQuantizedBvh)super.position(position); + } + @Override public btQuantizedBvh getPointer(long i) { + return new btQuantizedBvh((Pointer)this).offsetAddress(i); + } + + /** enum btQuantizedBvh::btTraversalMode */ + public static final int + TRAVERSAL_STACKLESS = 0, + TRAVERSAL_STACKLESS_CACHE_FRIENDLY = 1, + TRAVERSAL_RECURSIVE = 2; + + public btQuantizedBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + + ///***************************************** expert/internal use only ************************* + public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("btScalar") float quantizationMargin/*=btScalar(1.0)*/); + public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); + public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btVector3 getLeafNodeArray(); + /**buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized */ + public native void buildInternal(); + ///***************************************** expert/internal use only ************************* + + public native void reportAabbOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + public native void reportRayOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget); + public native void reportBoxCastOverlappingNodex(btNodeOverlapCallback nodeCallback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void quantize(@Cast("unsigned short*") ShortPointer out, @Const @ByRef btVector3 point, int isMax); + public native void quantize(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef btVector3 point, int isMax); + public native void quantize(@Cast("unsigned short*") short[] out, @Const @ByRef btVector3 point, int isMax); + + public native void quantizeWithClamp(@Cast("unsigned short*") ShortPointer out, @Const @ByRef btVector3 point2, int isMax); + public native void quantizeWithClamp(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef btVector3 point2, int isMax); + public native void quantizeWithClamp(@Cast("unsigned short*") short[] out, @Const @ByRef btVector3 point2, int isMax); + + public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") ShortPointer vecIn); + public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") ShortBuffer vecIn); + public native @ByVal btVector3 unQuantize(@Cast("const unsigned short*") short[] vecIn); + + /**setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees. */ + public native void setTraversalMode(@Cast("btQuantizedBvh::btTraversalMode") int traversalMode); + + public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btVector3 getQuantizedNodeArray(); + + public native @Cast("BvhSubtreeInfoArray*") @ByRef btAlignedObjectArray_btVector3 getSubtreeInfoArray(); + + //////////////////////////////////////////////////////////////////// + + /////Calculate space needed to store BVH for serialization + public native @Cast("unsigned") int calculateSerializeBufferSize(); + + /** Data buffer MUST be 16 byte aligned */ + public native @Cast("bool") boolean serialize(Pointer o_alignedDataBuffer, @Cast("unsigned") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + /**deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' */ + public static native btQuantizedBvh deSerializeInPlace(Pointer i_alignedDataBuffer, @Cast("unsigned int") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + public static native @Cast("unsigned int") int getAlignmentSerializationPadding(); + ////////////////////////////////////////////////////////////////////// + + public native int calculateSerializeBufferSizeNew(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void deSerializeFloat(@ByRef btQuantizedBvhFloatData quantizedBvhFloatData); + + public native void deSerializeDouble(@ByRef btQuantizedBvhDoubleData quantizedBvhDoubleData); + + //////////////////////////////////////////////////////////////////// + + public native @Cast("bool") boolean isQuantized(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhDoubleData.java new file mode 100644 index 00000000000..b00d9535f58 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhDoubleData.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btQuantizedBvhDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuantizedBvhDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuantizedBvhDoubleData position(long position) { + return (btQuantizedBvhDoubleData)super.position(position); + } + @Override public btQuantizedBvhDoubleData getPointer(long i) { + return new btQuantizedBvhDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3DoubleData m_bvhAabbMin(); public native btQuantizedBvhDoubleData m_bvhAabbMin(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_bvhAabbMax(); public native btQuantizedBvhDoubleData m_bvhAabbMax(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_bvhQuantization(); public native btQuantizedBvhDoubleData m_bvhQuantization(btVector3DoubleData setter); + public native int m_curNodeIndex(); public native btQuantizedBvhDoubleData m_curNodeIndex(int setter); + public native int m_useQuantization(); public native btQuantizedBvhDoubleData m_useQuantization(int setter); + public native int m_numContiguousLeafNodes(); public native btQuantizedBvhDoubleData m_numContiguousLeafNodes(int setter); + public native int m_numQuantizedContiguousNodes(); public native btQuantizedBvhDoubleData m_numQuantizedContiguousNodes(int setter); + public native btOptimizedBvhNodeDoubleData m_contiguousNodesPtr(); public native btQuantizedBvhDoubleData m_contiguousNodesPtr(btOptimizedBvhNodeDoubleData setter); + public native btQuantizedBvhNodeData m_quantizedContiguousNodesPtr(); public native btQuantizedBvhDoubleData m_quantizedContiguousNodesPtr(btQuantizedBvhNodeData setter); + + public native int m_traversalMode(); public native btQuantizedBvhDoubleData m_traversalMode(int setter); + public native int m_numSubtreeHeaders(); public native btQuantizedBvhDoubleData m_numSubtreeHeaders(int setter); + public native btBvhSubtreeInfoData m_subTreeInfoPtr(); public native btQuantizedBvhDoubleData m_subTreeInfoPtr(btBvhSubtreeInfoData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhFloatData.java new file mode 100644 index 00000000000..ff61cbbf1b3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhFloatData.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btQuantizedBvhFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuantizedBvhFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuantizedBvhFloatData position(long position) { + return (btQuantizedBvhFloatData)super.position(position); + } + @Override public btQuantizedBvhFloatData getPointer(long i) { + return new btQuantizedBvhFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_bvhAabbMin(); public native btQuantizedBvhFloatData m_bvhAabbMin(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_bvhAabbMax(); public native btQuantizedBvhFloatData m_bvhAabbMax(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_bvhQuantization(); public native btQuantizedBvhFloatData m_bvhQuantization(btVector3FloatData setter); + public native int m_curNodeIndex(); public native btQuantizedBvhFloatData m_curNodeIndex(int setter); + public native int m_useQuantization(); public native btQuantizedBvhFloatData m_useQuantization(int setter); + public native int m_numContiguousLeafNodes(); public native btQuantizedBvhFloatData m_numContiguousLeafNodes(int setter); + public native int m_numQuantizedContiguousNodes(); public native btQuantizedBvhFloatData m_numQuantizedContiguousNodes(int setter); + public native btOptimizedBvhNodeFloatData m_contiguousNodesPtr(); public native btQuantizedBvhFloatData m_contiguousNodesPtr(btOptimizedBvhNodeFloatData setter); + public native btQuantizedBvhNodeData m_quantizedContiguousNodesPtr(); public native btQuantizedBvhFloatData m_quantizedContiguousNodesPtr(btQuantizedBvhNodeData setter); + public native btBvhSubtreeInfoData m_subTreeInfoPtr(); public native btQuantizedBvhFloatData m_subTreeInfoPtr(btBvhSubtreeInfoData setter); + public native int m_traversalMode(); public native btQuantizedBvhFloatData m_traversalMode(int setter); + public native int m_numSubtreeHeaders(); public native btQuantizedBvhFloatData m_numSubtreeHeaders(int setter); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java new file mode 100644 index 00000000000..626914410cc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btQuantizedBvhNode is a compressed aabb node, 16 bytes. + * Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range). */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btQuantizedBvhNode extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuantizedBvhNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuantizedBvhNode position(long position) { + return (btQuantizedBvhNode)super.position(position); + } + @Override public btQuantizedBvhNode getPointer(long i) { + return new btQuantizedBvhNode((Pointer)this).offsetAddress(i); + } + + + //12 bytes + public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native btQuantizedBvhNode m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native btQuantizedBvhNode m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); + //4 bytes + public native int m_escapeIndexOrTriangleIndex(); public native btQuantizedBvhNode m_escapeIndexOrTriangleIndex(int setter); + + public native @Cast("bool") boolean isLeafNode(); + public native int getEscapeIndex(); + public native int getTriangleIndex(); + public native int getPartId(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java new file mode 100644 index 00000000000..2d6399d3003 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btQuantizedBvhNodeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuantizedBvhNodeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhNodeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhNodeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuantizedBvhNodeData position(long position) { + return (btQuantizedBvhNodeData)super.position(position); + } + @Override public btQuantizedBvhNodeData getPointer(long i) { + return new btQuantizedBvhNodeData((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned short") short m_quantizedAabbMin(int i); public native btQuantizedBvhNodeData m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short") short m_quantizedAabbMax(int i); public native btQuantizedBvhNodeData m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short*") ShortPointer m_quantizedAabbMax(); + public native int m_escapeIndexOrTriangleIndex(); public native btQuantizedBvhNodeData m_escapeIndexOrTriangleIndex(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btRigidBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btRigidBody.java new file mode 100644 index 00000000000..67b920352a7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btRigidBody.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btRigidBody extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btRigidBody() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBody(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledBvhTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledBvhTriangleMeshShape.java new file mode 100644 index 00000000000..20a906bd77d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledBvhTriangleMeshShape.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btScaledBvhTriangleMeshShape allows to instance a scaled version of an existing btBvhTriangleMeshShape. + * Note that each btBvhTriangleMeshShape still can have its own local scaling, independent from this btScaledBvhTriangleMeshShape 'localScaling' */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btScaledBvhTriangleMeshShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btScaledBvhTriangleMeshShape(Pointer p) { super(p); } + + + public btScaledBvhTriangleMeshShape(btBvhTriangleMeshShape childShape, @Const @ByRef btVector3 localScaling) { super((Pointer)null); allocate(childShape, localScaling); } + private native void allocate(btBvhTriangleMeshShape childShape, @Const @ByRef btVector3 localScaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native btBvhTriangleMeshShape getChildShape(); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledTriangleMeshShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledTriangleMeshShapeData.java new file mode 100644 index 00000000000..c76f733754a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledTriangleMeshShapeData.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btScaledTriangleMeshShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btScaledTriangleMeshShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btScaledTriangleMeshShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btScaledTriangleMeshShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btScaledTriangleMeshShapeData position(long position) { + return (btScaledTriangleMeshShapeData)super.position(position); + } + @Override public btScaledTriangleMeshShapeData getPointer(long i) { + return new btScaledTriangleMeshShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btTriangleMeshShapeData m_trimeshShapeData(); public native btScaledTriangleMeshShapeData m_trimeshShapeData(btTriangleMeshShapeData setter); + + public native @ByRef btVector3FloatData m_localScaling(); public native btScaledTriangleMeshShapeData m_localScaling(btVector3FloatData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexData.java new file mode 100644 index 00000000000..345e04aa21c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexData.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btShortIntIndexData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btShortIntIndexData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btShortIntIndexData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btShortIntIndexData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btShortIntIndexData position(long position) { + return (btShortIntIndexData)super.position(position); + } + @Override public btShortIntIndexData getPointer(long i) { + return new btShortIntIndexData((Pointer)this).offsetAddress(i); + } + + public native short m_value(); public native btShortIntIndexData m_value(short setter); + public native @Cast("char") byte m_pad(int i); public native btShortIntIndexData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexTripletData.java new file mode 100644 index 00000000000..5707cdb79fb --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexTripletData.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btShortIntIndexTripletData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btShortIntIndexTripletData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btShortIntIndexTripletData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btShortIntIndexTripletData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btShortIntIndexTripletData position(long position) { + return (btShortIntIndexTripletData)super.position(position); + } + @Override public btShortIntIndexTripletData getPointer(long i) { + return new btShortIntIndexTripletData((Pointer)this).offsetAddress(i); + } + + public native short m_values(int i); public native btShortIntIndexTripletData m_values(int i, short setter); + @MemberGetter public native ShortPointer m_values(); + public native @Cast("char") byte m_pad(int i); public native btShortIntIndexTripletData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java new file mode 100644 index 00000000000..fc2cfe0c4c8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java @@ -0,0 +1,61 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The SimpleBroadphase is just a unit-test for btAxisSweep3, bt32BitAxisSweep3, or btDbvtBroadphase, so use those classes instead. + * It is a brute force aabb culling broadphase based on O(n^2) aabb checks */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSimpleBroadphase extends btBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimpleBroadphase(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSimpleBroadphase(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSimpleBroadphase position(long position) { + return (btSimpleBroadphase)super.position(position); + } + @Override public btSimpleBroadphase getPointer(long i) { + return new btSimpleBroadphase((Pointer)this).offsetAddress(i); + } + + public btSimpleBroadphase(int maxProxies/*=16384*/, btOverlappingPairCache overlappingPairCache/*=0*/) { super((Pointer)null); allocate(maxProxies, overlappingPairCache); } + private native void allocate(int maxProxies/*=16384*/, btOverlappingPairCache overlappingPairCache/*=0*/); + public btSimpleBroadphase() { super((Pointer)null); allocate(); } + private native void allocate(); + + public static native @Cast("bool") boolean aabbOverlap(btSimpleBroadphaseProxy proxy0, btSimpleBroadphaseProxy proxy1); + + public native btBroadphaseProxy createProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask, btDispatcher dispatcher); + + public native void calculateOverlappingPairs(btDispatcher dispatcher); + + public native void destroyProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + public native void setAabb(btBroadphaseProxy proxy, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, btDispatcher dispatcher); + public native void getAabb(btBroadphaseProxy proxy, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMin, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 aabbMax); + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btBroadphaseRayCallback rayCallback); + public native void aabbTest(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, @ByRef btBroadphaseAabbCallback callback); + + public native btOverlappingPairCache getOverlappingPairCache(); + + public native @Cast("bool") boolean testAabbOverlap(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + /**getAabb returns the axis aligned bounding box in the 'global' coordinate frame + * will add some transform later */ + public native void getBroadphaseAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void printStats(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphaseProxy.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphaseProxy.java new file mode 100644 index 00000000000..ba5a618964f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphaseProxy.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSimpleBroadphaseProxy extends btBroadphaseProxy { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimpleBroadphaseProxy(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSimpleBroadphaseProxy(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSimpleBroadphaseProxy position(long position) { + return (btSimpleBroadphaseProxy)super.position(position); + } + @Override public btSimpleBroadphaseProxy getPointer(long i) { + return new btSimpleBroadphaseProxy((Pointer)this).offsetAddress(i); + } + + public native int m_nextFree(); public native btSimpleBroadphaseProxy m_nextFree(int setter); + + // int m_handleId; + + public btSimpleBroadphaseProxy() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btSimpleBroadphaseProxy(@Const @ByRef btVector3 minpt, @Const @ByRef btVector3 maxpt, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(minpt, maxpt, shapeType, userPtr, collisionFilterGroup, collisionFilterMask); } + private native void allocate(@Const @ByRef btVector3 minpt, @Const @ByRef btVector3 maxpt, int shapeType, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); + + public native void SetNextFree(int next); + public native int GetNextFree(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java new file mode 100644 index 00000000000..8f37fafe1d9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java @@ -0,0 +1,69 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btSortedOverlappingPairCache maintains the objects with overlapping AABB + * Typically managed by the Broadphase, Axis3Sweep or btSimpleBroadphase */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSortedOverlappingPairCache extends btOverlappingPairCache { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSortedOverlappingPairCache(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSortedOverlappingPairCache(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSortedOverlappingPairCache position(long position) { + return (btSortedOverlappingPairCache)super.position(position); + } + @Override public btSortedOverlappingPairCache getPointer(long i) { + return new btSortedOverlappingPairCache((Pointer)this).offsetAddress(i); + } + + public btSortedOverlappingPairCache() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void processAllOverlappingPairs(btOverlapCallback arg0, btDispatcher dispatcher); + + public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); + + public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); + + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native btBroadphasePair findPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native void cleanProxyFromPairs(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy proxy, btDispatcher dispatcher); + + public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + + + + + public native btBroadphasePair getOverlappingPairArrayPtr(); + + public native int getNumOverlappingPairs(); + + public native btOverlapFilterCallback getOverlapFilterCallback(); + + public native void setOverlapFilterCallback(btOverlapFilterCallback callback); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + public native void setInternalGhostPairCallback(btOverlappingPairCallback ghostPairCallback); + + public native void sortOverlappingPairs(btDispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereShape.java new file mode 100644 index 00000000000..6fc22da07ff --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereShape.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + // for the types + +/**The btSphereShape implements an implicit sphere, centered around a local origin with radius. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSphereShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSphereShape(Pointer p) { super(p); } + + + public btSphereShape(@Cast("btScalar") float radius) { super((Pointer)null); allocate(radius); } + private native void allocate(@Cast("btScalar") float radius); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + //notice that the vectors should be unit length + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native @Cast("btScalar") float getRadius(); + + public native void setUnscaledRadius(@Cast("btScalar") float radius); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java new file mode 100644 index 00000000000..5e055d2c3f8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java @@ -0,0 +1,56 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btSphereSphereCollisionAlgorithm provides sphere-sphere collision detection. + * Other features are frame-coherency (persistent data) and collision response. + * Also provides the most basic sample for custom/user btCollisionAlgorithm */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSphereSphereCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSphereSphereCollisionAlgorithm(Pointer p) { super(p); } + + public btSphereSphereCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap) { super((Pointer)null); allocate(mf, ci, col0Wrap, col1Wrap); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap); + + public btSphereSphereCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0Wrap, @Const btCollisionObjectWrapper col1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java new file mode 100644 index 00000000000..b031c2e02d4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btStaticPlaneShape simulates an infinite non-moving (static) collision plane. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btStaticPlaneShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStaticPlaneShape(Pointer p) { super(p); } + + + public btStaticPlaneShape(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConstant) { super((Pointer)null); allocate(planeNormal, planeConstant); } + private native void allocate(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConstant); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native @Const @ByRef btVector3 getPlaneNormal(); + + public native @Cast("const btScalar") float getPlaneConstant(); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java new file mode 100644 index 00000000000..7351f6a1fa0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btStaticPlaneShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btStaticPlaneShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btStaticPlaneShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStaticPlaneShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btStaticPlaneShapeData position(long position) { + return (btStaticPlaneShapeData)super.position(position); + } + @Override public btStaticPlaneShapeData getPointer(long i) { + return new btStaticPlaneShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btStaticPlaneShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native @ByRef btVector3FloatData m_localScaling(); public native btStaticPlaneShapeData m_localScaling(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_planeNormal(); public native btStaticPlaneShapeData m_planeNormal(btVector3FloatData setter); + public native float m_planeConstant(); public native btStaticPlaneShapeData m_planeConstant(float setter); + public native @Cast("char") byte m_pad(int i); public native btStaticPlaneShapeData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStorageResult.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStorageResult.java new file mode 100644 index 00000000000..9dc58e180d0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStorageResult.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btStorageResult extends btDiscreteCollisionDetectorInterface.Result { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStorageResult(Pointer p) { super(p); } + + public native @ByRef btVector3 m_normalOnSurfaceB(); public native btStorageResult m_normalOnSurfaceB(btVector3 setter); + public native @ByRef btVector3 m_closestPointInB(); public native btStorageResult m_closestPointInB(btVector3 setter); + public native @Cast("btScalar") float m_distance(); public native btStorageResult m_distance(float setter); + + public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterface.java new file mode 100644 index 00000000000..fd0f568f6e2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterface.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** The btStridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with btBvhTriangleMeshShape and some other collision shapes. + * Using index striding of 3*sizeof(integer) it can use triangle arrays, using index striding of 1*sizeof(integer) it can handle triangle strips. + * It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btStridingMeshInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStridingMeshInterface(Pointer p) { super(p); } + + + public native void InternalProcessAllTriangles(btInternalTriangleIndexCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + /**brute force method to calculate aabb */ + public native void calculateAabbBruteForce(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /** get read and write access to a subpart of a triangle mesh + * this subpart has a continuous array of vertices and indices + * in this way the mesh can be handled as chunks of memory with striding + * very similar to OpenGL vertexarray support + * make a call to unLockVertexBase when the read and write access is finished */ + public native void getLockedVertexIndexBase(@Cast("unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + /** unLockVertexBase finishes the access to a subpart of the triangle mesh + * make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished */ + public native void unLockVertexBase(int subpart); + + public native void unLockReadOnlyVertexBase(int subpart); + + /** getNumSubParts returns the number of separate subparts + * each subpart has a continuous array of vertices and indices */ + public native int getNumSubParts(); + + public native void preallocateVertices(int numverts); + public native void preallocateIndices(int numindices); + + public native @Cast("bool") boolean hasPremadeAabb(); + public native void setPremadeAabb(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + public native void getPremadeAabb(btVector3 aabbMin, btVector3 aabbMax); + + public native @Const @ByRef btVector3 getScaling(); + public native void setScaling(@Const @ByRef btVector3 scaling); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterfaceData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterfaceData.java new file mode 100644 index 00000000000..a1d115d6142 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterfaceData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btStridingMeshInterfaceData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btStridingMeshInterfaceData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btStridingMeshInterfaceData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStridingMeshInterfaceData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btStridingMeshInterfaceData position(long position) { + return (btStridingMeshInterfaceData)super.position(position); + } + @Override public btStridingMeshInterfaceData getPointer(long i) { + return new btStridingMeshInterfaceData((Pointer)this).offsetAddress(i); + } + + public native btMeshPartData m_meshPartsPtr(); public native btStridingMeshInterfaceData m_meshPartsPtr(btMeshPartData setter); + public native @ByRef btVector3FloatData m_scaling(); public native btStridingMeshInterfaceData m_scaling(btVector3FloatData setter); + public native int m_numMeshParts(); public native btStridingMeshInterfaceData m_numMeshParts(int setter); + public native @Cast("char") byte m_padding(int i); public native btStridingMeshInterfaceData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleCallback.java new file mode 100644 index 00000000000..568a9787f4c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleCallback.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btTriangleCallback provides a callback for each overlapping triangle when calling processAllTriangles. + * This callback is called by processAllTriangles for all btConcaveShape derived class, such as btBvhTriangleMeshShape, btStaticPlaneShape and btHeightfieldTerrainShape. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleCallback(Pointer p) { super(p); } + + public native void processTriangle(btVector3 triangle, int partId, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java new file mode 100644 index 00000000000..5df90e4441c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java @@ -0,0 +1,84 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btTriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays. + * Additional meshes can be added using addIndexedMesh + * No duplicate is made of the vertex/index data, it only indexes into external vertex/index arrays. + * So keep those arrays around during the lifetime of this btTriangleIndexVertexArray. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleIndexVertexArray extends btStridingMeshInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleIndexVertexArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleIndexVertexArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleIndexVertexArray position(long position) { + return (btTriangleIndexVertexArray)super.position(position); + } + @Override public btTriangleIndexVertexArray getPointer(long i) { + return new btTriangleIndexVertexArray((Pointer)this).offsetAddress(i); + } + + + public btTriangleIndexVertexArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + //just to be backwards compatible + public btTriangleIndexVertexArray(int numTriangles, IntPointer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatPointer vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, IntPointer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatPointer vertexBase, int vertexStride); + public btTriangleIndexVertexArray(int numTriangles, IntBuffer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatBuffer vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, IntBuffer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") FloatBuffer vertexBase, int vertexStride); + public btTriangleIndexVertexArray(int numTriangles, int[] triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") float[] vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, int[] triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("btScalar*") float[] vertexBase, int vertexStride); + + public native void addIndexedMesh(@Const @ByRef btIndexedMesh mesh, @Cast("PHY_ScalarType") int indexType/*=PHY_INTEGER*/); + public native void addIndexedMesh(@Const @ByRef btIndexedMesh mesh); + + public native void getLockedVertexIndexBase(@Cast("unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + /** unLockVertexBase finishes the access to a subpart of the triangle mesh + * make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished */ + public native void unLockVertexBase(int subpart); + + public native void unLockReadOnlyVertexBase(int subpart); + + /** getNumSubParts returns the number of separate subparts + * each subpart has a continuous array of vertices and indices */ + public native int getNumSubParts(); + + public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btVector3 getIndexedMeshArray(); + + public native void preallocateVertices(int numverts); + public native void preallocateIndices(int numindices); + + public native @Cast("bool") boolean hasPremadeAabb(); + public native void setPremadeAabb(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + public native void getPremadeAabb(btVector3 aabbMin, btVector3 aabbMax); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfo.java new file mode 100644 index 00000000000..f234d837919 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfo.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btTriangleInfo structure stores information to adjust collision normals to avoid collisions against internal edges + * it can be generated using */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleInfo position(long position) { + return (btTriangleInfo)super.position(position); + } + @Override public btTriangleInfo getPointer(long i) { + return new btTriangleInfo((Pointer)this).offsetAddress(i); + } + + public btTriangleInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native int m_flags(); public native btTriangleInfo m_flags(int setter); + + public native @Cast("btScalar") float m_edgeV0V1Angle(); public native btTriangleInfo m_edgeV0V1Angle(float setter); + public native @Cast("btScalar") float m_edgeV1V2Angle(); public native btTriangleInfo m_edgeV1V2Angle(float setter); + public native @Cast("btScalar") float m_edgeV2V0Angle(); public native btTriangleInfo m_edgeV2V0Angle(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java new file mode 100644 index 00000000000..e5673e41920 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off + +/**those fields have to be float and not btScalar for the serialization to work properly */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleInfoData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTriangleInfoData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleInfoData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleInfoData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTriangleInfoData position(long position) { + return (btTriangleInfoData)super.position(position); + } + @Override public btTriangleInfoData getPointer(long i) { + return new btTriangleInfoData((Pointer)this).offsetAddress(i); + } + + public native int m_flags(); public native btTriangleInfoData m_flags(int setter); + public native float m_edgeV0V1Angle(); public native btTriangleInfoData m_edgeV0V1Angle(float setter); + public native float m_edgeV1V2Angle(); public native btTriangleInfoData m_edgeV1V2Angle(float setter); + public native float m_edgeV2V0Angle(); public native btTriangleInfoData m_edgeV2V0Angle(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java new file mode 100644 index 00000000000..701b9994c1f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btTriangleInfoMap stores edge angle information for some triangles. You can compute this information yourself or using btGenerateInternalEdgeInfo. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleInfoMap extends btHashMap_btHashPtr_voidPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleInfoMap(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleInfoMap(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleInfoMap position(long position) { + return (btTriangleInfoMap)super.position(position); + } + @Override public btTriangleInfoMap getPointer(long i) { + return new btTriangleInfoMap((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_convexEpsilon(); public native btTriangleInfoMap m_convexEpsilon(float setter); /**used to determine if an edge or contact normal is convex, using the dot product */ + public native @Cast("btScalar") float m_planarEpsilon(); public native btTriangleInfoMap m_planarEpsilon(float setter); /**used to determine if a triangle edge is planar with zero angle */ + public native @Cast("btScalar") float m_equalVertexThreshold(); public native btTriangleInfoMap m_equalVertexThreshold(float setter); /**used to compute connectivity: if the distance between two vertices is smaller than m_equalVertexThreshold, they are considered to be 'shared' */ + public native @Cast("btScalar") float m_edgeDistanceThreshold(); public native btTriangleInfoMap m_edgeDistanceThreshold(float setter); /**used to determine edge contacts: if the closest distance between a contact point and an edge is smaller than this distance threshold it is considered to "hit the edge" */ + public native @Cast("btScalar") float m_maxEdgeAngleThreshold(); public native btTriangleInfoMap m_maxEdgeAngleThreshold(float setter); //ignore edges that connect triangles at an angle larger than this m_maxEdgeAngleThreshold + public native @Cast("btScalar") float m_zeroAreaThreshold(); public native btTriangleInfoMap m_zeroAreaThreshold(float setter); /**used to determine if a triangle is degenerate (length squared of cross product of 2 triangle edges < threshold) */ + + public btTriangleInfoMap() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void deSerialize(@ByRef btTriangleInfoMapData data); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java new file mode 100644 index 00000000000..7bbfe8ab9be --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleInfoMapData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTriangleInfoMapData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleInfoMapData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleInfoMapData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTriangleInfoMapData position(long position) { + return (btTriangleInfoMapData)super.position(position); + } + @Override public btTriangleInfoMapData getPointer(long i) { + return new btTriangleInfoMapData((Pointer)this).offsetAddress(i); + } + + public native IntPointer m_hashTablePtr(); public native btTriangleInfoMapData m_hashTablePtr(IntPointer setter); + public native IntPointer m_nextPtr(); public native btTriangleInfoMapData m_nextPtr(IntPointer setter); + public native btTriangleInfoData m_valueArrayPtr(); public native btTriangleInfoMapData m_valueArrayPtr(btTriangleInfoData setter); + public native IntPointer m_keyArrayPtr(); public native btTriangleInfoMapData m_keyArrayPtr(IntPointer setter); + + public native float m_convexEpsilon(); public native btTriangleInfoMapData m_convexEpsilon(float setter); + public native float m_planarEpsilon(); public native btTriangleInfoMapData m_planarEpsilon(float setter); + public native float m_equalVertexThreshold(); public native btTriangleInfoMapData m_equalVertexThreshold(float setter); + public native float m_edgeDistanceThreshold(); public native btTriangleInfoMapData m_edgeDistanceThreshold(float setter); + public native float m_zeroAreaThreshold(); public native btTriangleInfoMapData m_zeroAreaThreshold(float setter); + + public native int m_nextSize(); public native btTriangleInfoMapData m_nextSize(int setter); + public native int m_hashTableSize(); public native btTriangleInfoMapData m_hashTableSize(int setter); + public native int m_numValues(); public native btTriangleInfoMapData m_numValues(int setter); + public native int m_numKeys(); public native btTriangleInfoMapData m_numKeys(int setter); + public native @Cast("char") byte m_padding(int i); public native btTriangleInfoMapData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMesh.java new file mode 100644 index 00000000000..a9297489cd7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMesh.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btTriangleMesh class is a convenience class derived from btTriangleIndexVertexArray, that provides storage for a concave triangle mesh. It can be used as data for the btBvhTriangleMeshShape. + * It allows either 32bit or 16bit indices, and 4 (x-y-z-w) or 3 (x-y-z) component vertices. + * If you want to share triangle/index data between graphics mesh and collision mesh (btBvhTriangleMeshShape), you can directly use btTriangleIndexVertexArray or derive your own class from btStridingMeshInterface. + * Performance of btTriangleMesh and btTriangleIndexVertexArray used in a btBvhTriangleMeshShape is the same. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleMesh extends btTriangleIndexVertexArray { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleMesh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleMesh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleMesh position(long position) { + return (btTriangleMesh)super.position(position); + } + @Override public btTriangleMesh getPointer(long i) { + return new btTriangleMesh((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_weldingThreshold(); public native btTriangleMesh m_weldingThreshold(float setter); + + public btTriangleMesh(@Cast("bool") boolean use32bitIndices/*=true*/, @Cast("bool") boolean use4componentVertices/*=true*/) { super((Pointer)null); allocate(use32bitIndices, use4componentVertices); } + private native void allocate(@Cast("bool") boolean use32bitIndices/*=true*/, @Cast("bool") boolean use4componentVertices/*=true*/); + public btTriangleMesh() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean getUse32bitIndices(); + + public native @Cast("bool") boolean getUse4componentVertices(); + /**By default addTriangle won't search for duplicate vertices, because the search is very slow for large triangle meshes. + * In general it is better to directly use btTriangleIndexVertexArray instead. */ + public native void addTriangle(@Const @ByRef btVector3 vertex0, @Const @ByRef btVector3 vertex1, @Const @ByRef btVector3 vertex2, @Cast("bool") boolean removeDuplicateVertices/*=false*/); + public native void addTriangle(@Const @ByRef btVector3 vertex0, @Const @ByRef btVector3 vertex1, @Const @ByRef btVector3 vertex2); + + /**Add a triangle using its indices. Make sure the indices are pointing within the vertices array, so add the vertices first (and to be sure, avoid removal of duplicate vertices) */ + public native void addTriangleIndices(int index1, int index2, int index3); + + public native int getNumTriangles(); + + public native void preallocateVertices(int numverts); + public native void preallocateIndices(int numindices); + + /**findOrAddVertex is an internal method, use addTriangle instead */ + public native int findOrAddVertex(@Const @ByRef btVector3 vertex, @Cast("bool") boolean removeDuplicateVertices); + /**addIndex is an internal method, use addTriangle instead */ + public native void addIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShape.java new file mode 100644 index 00000000000..67d240718a6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShape.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btTriangleMeshShape is an internal concave triangle mesh interface. Don't use this class directly, use btBvhTriangleMeshShape instead. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleMeshShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleMeshShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void recalcLocalAabb(); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native btStridingMeshInterface getMeshInterface(); + + public native @Const @ByRef btVector3 getLocalAabbMin(); + public native @Const @ByRef btVector3 getLocalAabbMax(); + + //debugging + public native @Cast("const char*") BytePointer getName(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShapeData.java new file mode 100644 index 00000000000..a343ecf45a9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShapeData.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleMeshShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTriangleMeshShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleMeshShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleMeshShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTriangleMeshShapeData position(long position) { + return (btTriangleMeshShapeData)super.position(position); + } + @Override public btTriangleMeshShapeData getPointer(long i) { + return new btTriangleMeshShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btTriangleMeshShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native @ByRef btStridingMeshInterfaceData m_meshInterface(); public native btTriangleMeshShapeData m_meshInterface(btStridingMeshInterfaceData setter); + + public native btQuantizedBvhFloatData m_quantizedFloatBvh(); public native btTriangleMeshShapeData m_quantizedFloatBvh(btQuantizedBvhFloatData setter); + public native btQuantizedBvhDoubleData m_quantizedDoubleBvh(); public native btTriangleMeshShapeData m_quantizedDoubleBvh(btQuantizedBvhDoubleData setter); + + public native btTriangleInfoMapData m_triangleInfoMap(); public native btTriangleMeshShapeData m_triangleInfoMap(btTriangleInfoMapData setter); + + public native float m_collisionMargin(); public native btTriangleMeshShapeData m_collisionMargin(float setter); + + public native @Cast("char") byte m_pad3(int i); public native btTriangleMeshShapeData m_pad3(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad3(); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUniformScalingShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUniformScalingShape.java new file mode 100644 index 00000000000..a31121ba7f9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUniformScalingShape.java @@ -0,0 +1,58 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + // for the types + +/**The btUniformScalingShape allows to re-use uniform scaled instances of btConvexShape in a memory efficient way. + * Istead of using btUniformScalingShape, it is better to use the non-uniform setLocalScaling method on convex shapes that implement it. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btUniformScalingShape extends btConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btUniformScalingShape(Pointer p) { super(p); } + + + public btUniformScalingShape(btConvexShape convexChildShape, @Cast("btScalar") float uniformScalingFactor) { super((Pointer)null); allocate(convexChildShape, uniformScalingFactor); } + private native void allocate(btConvexShape convexChildShape, @Cast("btScalar") float uniformScalingFactor); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("btScalar") float getUniformScalingFactor(); + + public native btConvexShape getChildShape(); + + public native @Cast("const char*") BytePointer getName(); + + /////////////////////////// + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void getAabbSlow(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java new file mode 100644 index 00000000000..f5942182719 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btVoronoiSimplexSolver extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btVoronoiSimplexSolver() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVoronoiSimplexSolver(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics.java deleted file mode 100644 index 8c46999f97c..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics.java +++ /dev/null @@ -1,3860 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import static org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.BulletCollision.*; - -public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { - static { Loader.load(); } - -// Parsed from LinearMath/btAlignedObjectArray.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_OBJECT_ARRAY__ -// #define BT_OBJECT_ARRAY__ - -// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE -// #include "btAlignedAllocator.h" - -/**If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW - * then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors - * You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= - * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and - * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ - -public static final int BT_USE_PLACEMENT_NEW = 1; -//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... -// #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful - -// #ifdef BT_USE_MEMCPY -// #include -// #include -// #endif //BT_USE_MEMCPY - -// #ifdef BT_USE_PLACEMENT_NEW -// #include //for placement new -// #endif //BT_USE_PLACEMENT_NEW - -/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ -@Name("btAlignedObjectArray") @NoOffset public static class btAlignedObjectArray_btRigidBodyPointer extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btRigidBodyPointer(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btRigidBodyPointer(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btAlignedObjectArray_btRigidBodyPointer position(long position) { - return (btAlignedObjectArray_btRigidBodyPointer)super.position(position); - } - @Override public btAlignedObjectArray_btRigidBodyPointer getPointer(long i) { - return new btAlignedObjectArray_btRigidBodyPointer((Pointer)this).offsetAddress(i); - } - - public native @ByRef @Name("operator =") btAlignedObjectArray_btRigidBodyPointer put(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer other); - public btAlignedObjectArray_btRigidBodyPointer() { super((Pointer)null); allocate(); } - private native void allocate(); - - /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btRigidBodyPointer(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); - - /** return the number of elements in the array */ - public native int size(); - - public native @ByPtrRef btRigidBody at(int n); - - public native @ByPtrRef @Name("operator []") btRigidBody get(int n); - - /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ - public native void clear(); - - public native void pop_back(); - - /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. - * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ - public native void resizeNoInitialize(int newsize); - - public native void resize(int newsize, @ByPtrRef btRigidBody fillData/*=btRigidBody*()*/); - public native void resize(int newsize); - public native @ByPtrRef btRigidBody expandNonInitializing(); - - public native @ByPtrRef btRigidBody expand(@ByPtrRef btRigidBody fillValue/*=btRigidBody*()*/); - public native @ByPtrRef btRigidBody expand(); - - public native void push_back(@ByPtrRef btRigidBody _Val); - - /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ - public native @Name("capacity") int _capacity(); - - public native void reserve(int _Count); - - /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ - - public native void swap(int index0, int index1); - - /**non-recursive binary search, assumes sorted array */ - public native int findBinarySearch(@ByPtrRef btRigidBody key); - - public native int findLinearSearch(@ByPtrRef btRigidBody key); - - // If the key is not in the array, return -1 instead of 0, - // since 0 also means the first element in the array. - public native int findLinearSearch2(@ByPtrRef btRigidBody key); - - public native void removeAtIndex(int index); - public native void remove(@ByPtrRef btRigidBody key); - - //PCK: whole function - public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); -} - -// #endif //BT_OBJECT_ARRAY__ - - -// Parsed from BulletDynamics/Dynamics/btRigidBody.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_RIGIDBODY_H -// #define BT_RIGIDBODY_H - -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btTransform.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" -@Opaque public static class btTypedConstraint extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btTypedConstraint() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTypedConstraint(Pointer p) { super(p); } -} - -public static native @Cast("btScalar") float gDeactivationTime(); public static native void gDeactivationTime(float setter); -public static native @Cast("bool") boolean gDisableDeactivation(); public static native void gDisableDeactivation(boolean setter); - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btRigidBodyData btRigidBodyFloatData -public static final String btRigidBodyDataName = "btRigidBodyFloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -/** enum btRigidBodyFlags */ -public static final int - BT_DISABLE_WORLD_GRAVITY = 1, - /**BT_ENABLE_GYROPSCOPIC_FORCE flags is enabled by default in Bullet 2.83 and onwards. - * and it BT_ENABLE_GYROPSCOPIC_FORCE becomes equivalent to BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY - * See Demos/GyroscopicDemo and computeGyroscopicImpulseImplicit */ - BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT = 2, - BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD = 4, - BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY = 8, - BT_ENABLE_GYROPSCOPIC_FORCE = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY; - -/**The btRigidBody is the main class for rigid body objects. It is derived from btCollisionObject, so it keeps a pointer to a btCollisionShape. - * It is recommended for performance and memory use to share btCollisionShape objects whenever possible. - * There are 3 types of rigid bodies: - * - A) Dynamic rigid bodies, with positive mass. Motion is controlled by rigid body dynamics. - * - B) Fixed objects with zero mass. They are not moving (basically collision objects) - * - C) Kinematic objects, which are objects without mass, but the user can move them. There is one-way interaction, and Bullet calculates a velocity based on the timestep and previous and current world transform. - * Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time. - * Deactivated (sleeping) rigid bodies don't take any processing time, except a minor broadphase collision detection impact (to allow active objects to activate/wake up sleeping objects) */ -@NoOffset public static class btRigidBody extends btCollisionObject { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRigidBody(Pointer p) { super(p); } - - /**The btRigidBodyConstructionInfo structure provides information to create a rigid body. Setting mass to zero creates a fixed (non-dynamic) rigid body. - * For dynamic objects, you can use the collision shape to approximate the local inertia tensor, otherwise use the zero vector (default argument) - * You can use the motion state to synchronize the world transform between physics and graphics objects. - * And if the motion state is provided, the rigid body will initialize its initial world transform from the motion state, - * m_startWorldTransform is only used when you don't provide a motion state. */ - @NoOffset public static class btRigidBodyConstructionInfo extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRigidBodyConstructionInfo(Pointer p) { super(p); } - - public native @Cast("btScalar") float m_mass(); public native btRigidBodyConstructionInfo m_mass(float setter); - - /**When a motionState is provided, the rigid body will initialize its world transform from the motion state - * In this case, m_startWorldTransform is ignored. */ - public native btMotionState m_motionState(); public native btRigidBodyConstructionInfo m_motionState(btMotionState setter); - public native @ByRef btTransform m_startWorldTransform(); public native btRigidBodyConstructionInfo m_startWorldTransform(btTransform setter); - - public native btCollisionShape m_collisionShape(); public native btRigidBodyConstructionInfo m_collisionShape(btCollisionShape setter); - public native @ByRef btVector3 m_localInertia(); public native btRigidBodyConstructionInfo m_localInertia(btVector3 setter); - public native @Cast("btScalar") float m_linearDamping(); public native btRigidBodyConstructionInfo m_linearDamping(float setter); - public native @Cast("btScalar") float m_angularDamping(); public native btRigidBodyConstructionInfo m_angularDamping(float setter); - - /**best simulation results when friction is non-zero */ - public native @Cast("btScalar") float m_friction(); public native btRigidBodyConstructionInfo m_friction(float setter); - /**the m_rollingFriction prevents rounded shapes, such as spheres, cylinders and capsules from rolling forever. - * See Bullet/Demos/RollingFrictionDemo for usage */ - public native @Cast("btScalar") float m_rollingFriction(); public native btRigidBodyConstructionInfo m_rollingFriction(float setter); - public native @Cast("btScalar") float m_spinningFriction(); public native btRigidBodyConstructionInfo m_spinningFriction(float setter); //torsional friction around contact normal - - /**best simulation results using zero restitution. */ - public native @Cast("btScalar") float m_restitution(); public native btRigidBodyConstructionInfo m_restitution(float setter); - - public native @Cast("btScalar") float m_linearSleepingThreshold(); public native btRigidBodyConstructionInfo m_linearSleepingThreshold(float setter); - public native @Cast("btScalar") float m_angularSleepingThreshold(); public native btRigidBodyConstructionInfo m_angularSleepingThreshold(float setter); - - //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc. - //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete - public native @Cast("bool") boolean m_additionalDamping(); public native btRigidBodyConstructionInfo m_additionalDamping(boolean setter); - public native @Cast("btScalar") float m_additionalDampingFactor(); public native btRigidBodyConstructionInfo m_additionalDampingFactor(float setter); - public native @Cast("btScalar") float m_additionalLinearDampingThresholdSqr(); public native btRigidBodyConstructionInfo m_additionalLinearDampingThresholdSqr(float setter); - public native @Cast("btScalar") float m_additionalAngularDampingThresholdSqr(); public native btRigidBodyConstructionInfo m_additionalAngularDampingThresholdSqr(float setter); - public native @Cast("btScalar") float m_additionalAngularDampingFactor(); public native btRigidBodyConstructionInfo m_additionalAngularDampingFactor(float setter); - - public btRigidBodyConstructionInfo(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia) { super((Pointer)null); allocate(mass, motionState, collisionShape, localInertia); } - private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia); - public btRigidBodyConstructionInfo(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape) { super((Pointer)null); allocate(mass, motionState, collisionShape); } - private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape); - } - - /**btRigidBody constructor using construction info */ - public btRigidBody(@Const @ByRef btRigidBodyConstructionInfo constructionInfo) { super((Pointer)null); allocate(constructionInfo); } - private native void allocate(@Const @ByRef btRigidBodyConstructionInfo constructionInfo); - - /**btRigidBody constructor for backwards compatibility. - * To specify friction (etc) during rigid body construction, please use the other constructor (using btRigidBodyConstructionInfo) */ - public btRigidBody(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia) { super((Pointer)null); allocate(mass, motionState, collisionShape, localInertia); } - private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia); - public btRigidBody(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape) { super((Pointer)null); allocate(mass, motionState, collisionShape); } - private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape); - public native void proceedToTransform(@Const @ByRef btTransform newTrans); - - /**to keep collision detection and dynamics separate we don't store a rigidbody pointer - * but a rigidbody is derived from btCollisionObject, so we can safely perform an upcast */ - public static native @Const btRigidBody upcast(@Const btCollisionObject colObj); - - /** continuous collision detection needs prediction */ - public native void predictIntegratedTransform(@Cast("btScalar") float step, @ByRef btTransform predictedTransform); - - public native void saveKinematicState(@Cast("btScalar") float step); - - public native void applyGravity(); - - public native void clearGravity(); - - public native void setGravity(@Const @ByRef btVector3 acceleration); - - public native @Const @ByRef btVector3 getGravity(); - - public native void setDamping(@Cast("btScalar") float lin_damping, @Cast("btScalar") float ang_damping); - - public native @Cast("btScalar") float getLinearDamping(); - - public native @Cast("btScalar") float getAngularDamping(); - - public native @Cast("btScalar") float getLinearSleepingThreshold(); - - public native @Cast("btScalar") float getAngularSleepingThreshold(); - - public native void applyDamping(@Cast("btScalar") float timeStep); - - public native btCollisionShape getCollisionShape(); - - public native void setMassProps(@Cast("btScalar") float mass, @Const @ByRef btVector3 inertia); - - public native @Const @ByRef btVector3 getLinearFactor(); - public native void setLinearFactor(@Const @ByRef btVector3 linearFactor); - public native @Cast("btScalar") float getInvMass(); - public native @Cast("btScalar") float getMass(); - public native @Const @ByRef btMatrix3x3 getInvInertiaTensorWorld(); - - public native void integrateVelocities(@Cast("btScalar") float step); - - public native void setCenterOfMassTransform(@Const @ByRef btTransform xform); - - public native void applyCentralForce(@Const @ByRef btVector3 force); - - public native @Const @ByRef btVector3 getTotalForce(); - - public native @Const @ByRef btVector3 getTotalTorque(); - - public native @Const @ByRef btVector3 getInvInertiaDiagLocal(); - - public native void setInvInertiaDiagLocal(@Const @ByRef btVector3 diagInvInertia); - - public native void setSleepingThresholds(@Cast("btScalar") float linear, @Cast("btScalar") float angular); - - public native void applyTorque(@Const @ByRef btVector3 torque); - - public native void applyForce(@Const @ByRef btVector3 force, @Const @ByRef btVector3 rel_pos); - - public native void applyCentralImpulse(@Const @ByRef btVector3 impulse); - - public native void applyTorqueImpulse(@Const @ByRef btVector3 torque); - - public native void applyImpulse(@Const @ByRef btVector3 impulse, @Const @ByRef btVector3 rel_pos); - - public native void applyPushImpulse(@Const @ByRef btVector3 impulse, @Const @ByRef btVector3 rel_pos); - - public native @ByVal btVector3 getPushVelocity(); - - public native @ByVal btVector3 getTurnVelocity(); - - public native void setPushVelocity(@Const @ByRef btVector3 v); - -// #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 -// #endif - - public native void setTurnVelocity(@Const @ByRef btVector3 v); - - public native void applyCentralPushImpulse(@Const @ByRef btVector3 impulse); - - public native void applyTorqueTurnImpulse(@Const @ByRef btVector3 torque); - - public native void clearForces(); - - public native void updateInertiaTensor(); - - public native @Const @ByRef btVector3 getCenterOfMassPosition(); - public native @ByVal btQuaternion getOrientation(); - - public native @Const @ByRef btTransform getCenterOfMassTransform(); - public native @Const @ByRef btVector3 getLinearVelocity(); - public native @Const @ByRef btVector3 getAngularVelocity(); - - public native void setLinearVelocity(@Const @ByRef btVector3 lin_vel); - - public native void setAngularVelocity(@Const @ByRef btVector3 ang_vel); - - public native @ByVal btVector3 getVelocityInLocalPoint(@Const @ByRef btVector3 rel_pos); - - public native @ByVal btVector3 getPushVelocityInLocalPoint(@Const @ByRef btVector3 rel_pos); - - public native void translate(@Const @ByRef btVector3 v); - - public native void getAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); - - public native @Cast("btScalar") float computeImpulseDenominator(@Const @ByRef btVector3 pos, @Const @ByRef btVector3 normal); - - public native @Cast("btScalar") float computeAngularImpulseDenominator(@Const @ByRef btVector3 axis); - - public native void updateDeactivation(@Cast("btScalar") float timeStep); - - public native @Cast("bool") boolean wantsSleeping(); - public native btBroadphaseProxy getBroadphaseProxy(); - public native void setNewBroadphaseProxy(btBroadphaseProxy broadphaseProxy); - - //btMotionState allows to automatic synchronize the world transform for active objects - public native btMotionState getMotionState(); - public native void setMotionState(btMotionState motionState); - - //for experimental overriding of friction/contact solver func - public native int m_contactSolverType(); public native btRigidBody m_contactSolverType(int setter); - public native int m_frictionSolverType(); public native btRigidBody m_frictionSolverType(int setter); - - public native void setAngularFactor(@Const @ByRef btVector3 angFac); - - public native void setAngularFactor(@Cast("btScalar") float angFac); - public native @Const @ByRef btVector3 getAngularFactor(); - - //is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBroadphase? - public native @Cast("bool") boolean isInWorld(); - - public native void addConstraintRef(btTypedConstraint c); - public native void removeConstraintRef(btTypedConstraint c); - - public native btTypedConstraint getConstraintRef(int index); - - public native int getNumConstraintRefs(); - - public native void setFlags(int flags); - - public native int getFlags(); - - /**perform implicit force computation in world space */ - public native @ByVal btVector3 computeGyroscopicImpulseImplicit_World(@Cast("btScalar") float dt); - - /**perform implicit force computation in body space (inertial frame) */ - public native @ByVal btVector3 computeGyroscopicImpulseImplicit_Body(@Cast("btScalar") float step); - - /**explicit version is best avoided, it gains energy */ - public native @ByVal btVector3 computeGyroscopicForceExplicit(@Cast("btScalar") float maxGyroscopicForce); - public native @ByVal btVector3 getLocalInertia(); - - /////////////////////////////////////////////// - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); - - public native void serializeSingleObject(btSerializer serializer); -} - -//@todo add m_optionalMotionState and m_constraintRefs to btRigidBodyData -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btRigidBodyFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btRigidBodyFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btRigidBodyFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRigidBodyFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btRigidBodyFloatData position(long position) { - return (btRigidBodyFloatData)super.position(position); - } - @Override public btRigidBodyFloatData getPointer(long i) { - return new btRigidBodyFloatData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btCollisionObjectFloatData m_collisionObjectData(); public native btRigidBodyFloatData m_collisionObjectData(btCollisionObjectFloatData setter); - public native @ByRef btMatrix3x3FloatData m_invInertiaTensorWorld(); public native btRigidBodyFloatData m_invInertiaTensorWorld(btMatrix3x3FloatData setter); - public native @ByRef btVector3FloatData m_linearVelocity(); public native btRigidBodyFloatData m_linearVelocity(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularVelocity(); public native btRigidBodyFloatData m_angularVelocity(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularFactor(); public native btRigidBodyFloatData m_angularFactor(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearFactor(); public native btRigidBodyFloatData m_linearFactor(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_gravity(); public native btRigidBodyFloatData m_gravity(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_gravity_acceleration(); public native btRigidBodyFloatData m_gravity_acceleration(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_invInertiaLocal(); public native btRigidBodyFloatData m_invInertiaLocal(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_totalForce(); public native btRigidBodyFloatData m_totalForce(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_totalTorque(); public native btRigidBodyFloatData m_totalTorque(btVector3FloatData setter); - public native float m_inverseMass(); public native btRigidBodyFloatData m_inverseMass(float setter); - public native float m_linearDamping(); public native btRigidBodyFloatData m_linearDamping(float setter); - public native float m_angularDamping(); public native btRigidBodyFloatData m_angularDamping(float setter); - public native float m_additionalDampingFactor(); public native btRigidBodyFloatData m_additionalDampingFactor(float setter); - public native float m_additionalLinearDampingThresholdSqr(); public native btRigidBodyFloatData m_additionalLinearDampingThresholdSqr(float setter); - public native float m_additionalAngularDampingThresholdSqr(); public native btRigidBodyFloatData m_additionalAngularDampingThresholdSqr(float setter); - public native float m_additionalAngularDampingFactor(); public native btRigidBodyFloatData m_additionalAngularDampingFactor(float setter); - public native float m_linearSleepingThreshold(); public native btRigidBodyFloatData m_linearSleepingThreshold(float setter); - public native float m_angularSleepingThreshold(); public native btRigidBodyFloatData m_angularSleepingThreshold(float setter); - public native int m_additionalDamping(); public native btRigidBodyFloatData m_additionalDamping(int setter); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btRigidBodyDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btRigidBodyDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btRigidBodyDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRigidBodyDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btRigidBodyDoubleData position(long position) { - return (btRigidBodyDoubleData)super.position(position); - } - @Override public btRigidBodyDoubleData getPointer(long i) { - return new btRigidBodyDoubleData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btCollisionObjectDoubleData m_collisionObjectData(); public native btRigidBodyDoubleData m_collisionObjectData(btCollisionObjectDoubleData setter); - public native @ByRef btMatrix3x3DoubleData m_invInertiaTensorWorld(); public native btRigidBodyDoubleData m_invInertiaTensorWorld(btMatrix3x3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearVelocity(); public native btRigidBodyDoubleData m_linearVelocity(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularVelocity(); public native btRigidBodyDoubleData m_angularVelocity(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularFactor(); public native btRigidBodyDoubleData m_angularFactor(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearFactor(); public native btRigidBodyDoubleData m_linearFactor(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_gravity(); public native btRigidBodyDoubleData m_gravity(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_gravity_acceleration(); public native btRigidBodyDoubleData m_gravity_acceleration(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_invInertiaLocal(); public native btRigidBodyDoubleData m_invInertiaLocal(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_totalForce(); public native btRigidBodyDoubleData m_totalForce(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_totalTorque(); public native btRigidBodyDoubleData m_totalTorque(btVector3DoubleData setter); - public native double m_inverseMass(); public native btRigidBodyDoubleData m_inverseMass(double setter); - public native double m_linearDamping(); public native btRigidBodyDoubleData m_linearDamping(double setter); - public native double m_angularDamping(); public native btRigidBodyDoubleData m_angularDamping(double setter); - public native double m_additionalDampingFactor(); public native btRigidBodyDoubleData m_additionalDampingFactor(double setter); - public native double m_additionalLinearDampingThresholdSqr(); public native btRigidBodyDoubleData m_additionalLinearDampingThresholdSqr(double setter); - public native double m_additionalAngularDampingThresholdSqr(); public native btRigidBodyDoubleData m_additionalAngularDampingThresholdSqr(double setter); - public native double m_additionalAngularDampingFactor(); public native btRigidBodyDoubleData m_additionalAngularDampingFactor(double setter); - public native double m_linearSleepingThreshold(); public native btRigidBodyDoubleData m_linearSleepingThreshold(double setter); - public native double m_angularSleepingThreshold(); public native btRigidBodyDoubleData m_angularSleepingThreshold(double setter); - public native int m_additionalDamping(); public native btRigidBodyDoubleData m_additionalDamping(int setter); - public native @Cast("char") byte m_padding(int i); public native btRigidBodyDoubleData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - -// #endif //BT_RIGIDBODY_H - - -// Parsed from BulletDynamics/Dynamics/btDynamicsWorld.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_DYNAMICS_WORLD_H -// #define BT_DYNAMICS_WORLD_H - -// #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" -// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" -@Opaque public static class btActionInterface extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btActionInterface() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btActionInterface(Pointer p) { super(p); } -} - -/** Type for the callback for each tick */ -public static class btInternalTickCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btInternalTickCallback(Pointer p) { super(p); } - protected btInternalTickCallback() { allocate(); } - private native void allocate(); - public native void call(btDynamicsWorld world, @Cast("btScalar") float timeStep); -} - -/** enum btDynamicsWorldType */ -public static final int - BT_SIMPLE_DYNAMICS_WORLD = 1, - BT_DISCRETE_DYNAMICS_WORLD = 2, - BT_CONTINUOUS_DYNAMICS_WORLD = 3, - BT_SOFT_RIGID_DYNAMICS_WORLD = 4, - BT_GPU_DYNAMICS_WORLD = 5, - BT_SOFT_MULTIBODY_DYNAMICS_WORLD = 6, - BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD = 7; - -/**The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc. */ -@NoOffset public static class btDynamicsWorld extends btCollisionWorld { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDynamicsWorld(Pointer p) { super(p); } - - - /**stepSimulation proceeds the simulation over 'timeStep', units in preferably in seconds. - * By default, Bullet will subdivide the timestep in constant substeps of each 'fixedTimeStep'. - * in order to keep the simulation real-time, the maximum number of substeps can be clamped to 'maxSubSteps'. - * You can disable subdividing the timestep/substepping by passing maxSubSteps=0 as second argument to stepSimulation, but in that case you have to keep the timeStep constant. */ - public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); - public native int stepSimulation(@Cast("btScalar") float timeStep); - - public native void debugDrawWorld(); - - public native void addConstraint(btTypedConstraint constraint, @Cast("bool") boolean disableCollisionsBetweenLinkedBodies/*=false*/); - public native void addConstraint(btTypedConstraint constraint); - - public native void removeConstraint(btTypedConstraint constraint); - - public native void addAction(btActionInterface action); - - public native void removeAction(btActionInterface action); - - //once a rigidbody is added to the dynamics world, it will get this gravity assigned - //existing rigidbodies in the world get gravity assigned too, during this method - public native void setGravity(@Const @ByRef btVector3 gravity); - public native @ByVal btVector3 getGravity(); - - public native void synchronizeMotionStates(); - - public native void addRigidBody(btRigidBody body); - - public native void addRigidBody(btRigidBody body, int group, int mask); - - public native void removeRigidBody(btRigidBody body); - - public native void setConstraintSolver(btConstraintSolver solver); - - public native btConstraintSolver getConstraintSolver(); - - public native int getNumConstraints(); - - public native btTypedConstraint getConstraint(int index); - - public native @Cast("btDynamicsWorldType") int getWorldType(); - - public native void clearForces(); - - /** Set the callback for when an internal tick (simulation substep) happens, optional user info */ - public native void setInternalTickCallback(btInternalTickCallback cb, Pointer worldUserInfo/*=0*/, @Cast("bool") boolean isPreTick/*=false*/); - public native void setInternalTickCallback(btInternalTickCallback cb); - - public native void setWorldUserInfo(Pointer worldUserInfo); - - public native Pointer getWorldUserInfo(); - - public native @ByRef btContactSolverInfo getSolverInfo(); - - /**obsolete, use addAction instead. */ - public native void addVehicle(btActionInterface vehicle); - /**obsolete, use removeAction instead */ - public native void removeVehicle(btActionInterface vehicle); - /**obsolete, use addAction instead. */ - public native void addCharacter(btActionInterface character); - /**obsolete, use removeAction instead */ - public native void removeCharacter(btActionInterface character); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btDynamicsWorldDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btDynamicsWorldDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btDynamicsWorldDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDynamicsWorldDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btDynamicsWorldDoubleData position(long position) { - return (btDynamicsWorldDoubleData)super.position(position); - } - @Override public btDynamicsWorldDoubleData getPointer(long i) { - return new btDynamicsWorldDoubleData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btContactSolverInfoDoubleData m_solverInfo(); public native btDynamicsWorldDoubleData m_solverInfo(btContactSolverInfoDoubleData setter); - public native @ByRef btVector3DoubleData m_gravity(); public native btDynamicsWorldDoubleData m_gravity(btVector3DoubleData setter); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btDynamicsWorldFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btDynamicsWorldFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btDynamicsWorldFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDynamicsWorldFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btDynamicsWorldFloatData position(long position) { - return (btDynamicsWorldFloatData)super.position(position); - } - @Override public btDynamicsWorldFloatData getPointer(long i) { - return new btDynamicsWorldFloatData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btContactSolverInfoFloatData m_solverInfo(); public native btDynamicsWorldFloatData m_solverInfo(btContactSolverInfoFloatData setter); - public native @ByRef btVector3FloatData m_gravity(); public native btDynamicsWorldFloatData m_gravity(btVector3FloatData setter); -} - -// #endif //BT_DYNAMICS_WORLD_H - - -// Parsed from BulletDynamics/ConstraintSolver/btContactSolverInfo.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CONTACT_SOLVER_INFO -// #define BT_CONTACT_SOLVER_INFO - -// #include "LinearMath/btScalar.h" - -/** enum btSolverMode */ -public static final int - SOLVER_RANDMIZE_ORDER = 1, - SOLVER_FRICTION_SEPARATE = 2, - SOLVER_USE_WARMSTARTING = 4, - SOLVER_USE_2_FRICTION_DIRECTIONS = 16, - SOLVER_ENABLE_FRICTION_DIRECTION_CACHING = 32, - SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION = 64, - SOLVER_CACHE_FRIENDLY = 128, - SOLVER_SIMD = 256, - SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS = 512, - SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS = 1024, - SOLVER_DISABLE_IMPLICIT_CONE_FRICTION = 2048, - SOLVER_USE_ARTICULATED_WARMSTARTING = 4096; - -public static class btContactSolverInfoData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btContactSolverInfoData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btContactSolverInfoData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btContactSolverInfoData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btContactSolverInfoData position(long position) { - return (btContactSolverInfoData)super.position(position); - } - @Override public btContactSolverInfoData getPointer(long i) { - return new btContactSolverInfoData((Pointer)this).offsetAddress(i); - } - - public native @Cast("btScalar") float m_tau(); public native btContactSolverInfoData m_tau(float setter); - public native @Cast("btScalar") float m_damping(); public native btContactSolverInfoData m_damping(float setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. - public native @Cast("btScalar") float m_friction(); public native btContactSolverInfoData m_friction(float setter); - public native @Cast("btScalar") float m_timeStep(); public native btContactSolverInfoData m_timeStep(float setter); - public native @Cast("btScalar") float m_restitution(); public native btContactSolverInfoData m_restitution(float setter); - public native int m_numIterations(); public native btContactSolverInfoData m_numIterations(int setter); - public native @Cast("btScalar") float m_maxErrorReduction(); public native btContactSolverInfoData m_maxErrorReduction(float setter); - public native @Cast("btScalar") float m_sor(); public native btContactSolverInfoData m_sor(float setter); //successive over-relaxation term - public native @Cast("btScalar") float m_erp(); public native btContactSolverInfoData m_erp(float setter); //error reduction for non-contact constraints - public native @Cast("btScalar") float m_erp2(); public native btContactSolverInfoData m_erp2(float setter); //error reduction for contact constraints - public native @Cast("btScalar") float m_deformable_erp(); public native btContactSolverInfoData m_deformable_erp(float setter); //error reduction for deformable constraints - public native @Cast("btScalar") float m_deformable_cfm(); public native btContactSolverInfoData m_deformable_cfm(float setter); //constraint force mixing for deformable constraints - public native @Cast("btScalar") float m_deformable_maxErrorReduction(); public native btContactSolverInfoData m_deformable_maxErrorReduction(float setter); // maxErrorReduction for deformable contact - public native @Cast("btScalar") float m_globalCfm(); public native btContactSolverInfoData m_globalCfm(float setter); //constraint force mixing for contacts and non-contacts - public native @Cast("btScalar") float m_frictionERP(); public native btContactSolverInfoData m_frictionERP(float setter); //error reduction for friction constraints - public native @Cast("btScalar") float m_frictionCFM(); public native btContactSolverInfoData m_frictionCFM(float setter); //constraint force mixing for friction constraints - - public native int m_splitImpulse(); public native btContactSolverInfoData m_splitImpulse(int setter); - public native @Cast("btScalar") float m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoData m_splitImpulsePenetrationThreshold(float setter); - public native @Cast("btScalar") float m_splitImpulseTurnErp(); public native btContactSolverInfoData m_splitImpulseTurnErp(float setter); - public native @Cast("btScalar") float m_linearSlop(); public native btContactSolverInfoData m_linearSlop(float setter); - public native @Cast("btScalar") float m_warmstartingFactor(); public native btContactSolverInfoData m_warmstartingFactor(float setter); - public native @Cast("btScalar") float m_articulatedWarmstartingFactor(); public native btContactSolverInfoData m_articulatedWarmstartingFactor(float setter); - public native int m_solverMode(); public native btContactSolverInfoData m_solverMode(int setter); - public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoData m_restingContactRestitutionThreshold(int setter); - public native int m_minimumSolverBatchSize(); public native btContactSolverInfoData m_minimumSolverBatchSize(int setter); - public native @Cast("btScalar") float m_maxGyroscopicForce(); public native btContactSolverInfoData m_maxGyroscopicForce(float setter); - public native @Cast("btScalar") float m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoData m_singleAxisRollingFrictionThreshold(float setter); - public native @Cast("btScalar") float m_leastSquaresResidualThreshold(); public native btContactSolverInfoData m_leastSquaresResidualThreshold(float setter); - public native @Cast("btScalar") float m_restitutionVelocityThreshold(); public native btContactSolverInfoData m_restitutionVelocityThreshold(float setter); - public native @Cast("bool") boolean m_jointFeedbackInWorldSpace(); public native btContactSolverInfoData m_jointFeedbackInWorldSpace(boolean setter); - public native @Cast("bool") boolean m_jointFeedbackInJointFrame(); public native btContactSolverInfoData m_jointFeedbackInJointFrame(boolean setter); - public native int m_reportSolverAnalytics(); public native btContactSolverInfoData m_reportSolverAnalytics(int setter); - public native int m_numNonContactInnerIterations(); public native btContactSolverInfoData m_numNonContactInnerIterations(int setter); -} - -public static class btContactSolverInfo extends btContactSolverInfoData { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btContactSolverInfo(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btContactSolverInfo(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btContactSolverInfo position(long position) { - return (btContactSolverInfo)super.position(position); - } - @Override public btContactSolverInfo getPointer(long i) { - return new btContactSolverInfo((Pointer)this).offsetAddress(i); - } - - public btContactSolverInfo() { super((Pointer)null); allocate(); } - private native void allocate(); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btContactSolverInfoDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btContactSolverInfoDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btContactSolverInfoDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btContactSolverInfoDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btContactSolverInfoDoubleData position(long position) { - return (btContactSolverInfoDoubleData)super.position(position); - } - @Override public btContactSolverInfoDoubleData getPointer(long i) { - return new btContactSolverInfoDoubleData((Pointer)this).offsetAddress(i); - } - - public native double m_tau(); public native btContactSolverInfoDoubleData m_tau(double setter); - public native double m_damping(); public native btContactSolverInfoDoubleData m_damping(double setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. - public native double m_friction(); public native btContactSolverInfoDoubleData m_friction(double setter); - public native double m_timeStep(); public native btContactSolverInfoDoubleData m_timeStep(double setter); - public native double m_restitution(); public native btContactSolverInfoDoubleData m_restitution(double setter); - public native double m_maxErrorReduction(); public native btContactSolverInfoDoubleData m_maxErrorReduction(double setter); - public native double m_sor(); public native btContactSolverInfoDoubleData m_sor(double setter); - public native double m_erp(); public native btContactSolverInfoDoubleData m_erp(double setter); //used as Baumgarte factor - public native double m_erp2(); public native btContactSolverInfoDoubleData m_erp2(double setter); //used in Split Impulse - public native double m_globalCfm(); public native btContactSolverInfoDoubleData m_globalCfm(double setter); //constraint force mixing - public native double m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoDoubleData m_splitImpulsePenetrationThreshold(double setter); - public native double m_splitImpulseTurnErp(); public native btContactSolverInfoDoubleData m_splitImpulseTurnErp(double setter); - public native double m_linearSlop(); public native btContactSolverInfoDoubleData m_linearSlop(double setter); - public native double m_warmstartingFactor(); public native btContactSolverInfoDoubleData m_warmstartingFactor(double setter); - public native double m_articulatedWarmstartingFactor(); public native btContactSolverInfoDoubleData m_articulatedWarmstartingFactor(double setter); - public native double m_maxGyroscopicForce(); public native btContactSolverInfoDoubleData m_maxGyroscopicForce(double setter); /**it is only used for 'explicit' version of gyroscopic force */ - public native double m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoDoubleData m_singleAxisRollingFrictionThreshold(double setter); - - public native int m_numIterations(); public native btContactSolverInfoDoubleData m_numIterations(int setter); - public native int m_solverMode(); public native btContactSolverInfoDoubleData m_solverMode(int setter); - public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoDoubleData m_restingContactRestitutionThreshold(int setter); - public native int m_minimumSolverBatchSize(); public native btContactSolverInfoDoubleData m_minimumSolverBatchSize(int setter); - public native int m_splitImpulse(); public native btContactSolverInfoDoubleData m_splitImpulse(int setter); - public native @Cast("char") byte m_padding(int i); public native btContactSolverInfoDoubleData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btContactSolverInfoFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btContactSolverInfoFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btContactSolverInfoFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btContactSolverInfoFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btContactSolverInfoFloatData position(long position) { - return (btContactSolverInfoFloatData)super.position(position); - } - @Override public btContactSolverInfoFloatData getPointer(long i) { - return new btContactSolverInfoFloatData((Pointer)this).offsetAddress(i); - } - - public native float m_tau(); public native btContactSolverInfoFloatData m_tau(float setter); - public native float m_damping(); public native btContactSolverInfoFloatData m_damping(float setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. - public native float m_friction(); public native btContactSolverInfoFloatData m_friction(float setter); - public native float m_timeStep(); public native btContactSolverInfoFloatData m_timeStep(float setter); - - public native float m_restitution(); public native btContactSolverInfoFloatData m_restitution(float setter); - public native float m_maxErrorReduction(); public native btContactSolverInfoFloatData m_maxErrorReduction(float setter); - public native float m_sor(); public native btContactSolverInfoFloatData m_sor(float setter); - public native float m_erp(); public native btContactSolverInfoFloatData m_erp(float setter); //used as Baumgarte factor - - public native float m_erp2(); public native btContactSolverInfoFloatData m_erp2(float setter); //used in Split Impulse - public native float m_globalCfm(); public native btContactSolverInfoFloatData m_globalCfm(float setter); //constraint force mixing - public native float m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoFloatData m_splitImpulsePenetrationThreshold(float setter); - public native float m_splitImpulseTurnErp(); public native btContactSolverInfoFloatData m_splitImpulseTurnErp(float setter); - - public native float m_linearSlop(); public native btContactSolverInfoFloatData m_linearSlop(float setter); - public native float m_warmstartingFactor(); public native btContactSolverInfoFloatData m_warmstartingFactor(float setter); - public native float m_articulatedWarmstartingFactor(); public native btContactSolverInfoFloatData m_articulatedWarmstartingFactor(float setter); - public native float m_maxGyroscopicForce(); public native btContactSolverInfoFloatData m_maxGyroscopicForce(float setter); - - public native float m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoFloatData m_singleAxisRollingFrictionThreshold(float setter); - public native int m_numIterations(); public native btContactSolverInfoFloatData m_numIterations(int setter); - public native int m_solverMode(); public native btContactSolverInfoFloatData m_solverMode(int setter); - public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoFloatData m_restingContactRestitutionThreshold(int setter); - - public native int m_minimumSolverBatchSize(); public native btContactSolverInfoFloatData m_minimumSolverBatchSize(int setter); - public native int m_splitImpulse(); public native btContactSolverInfoFloatData m_splitImpulse(int setter); - -} - -// #endif //BT_CONTACT_SOLVER_INFO - - -// Parsed from BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_DISCRETE_DYNAMICS_WORLD_H -// #define BT_DISCRETE_DYNAMICS_WORLD_H - -// #include "btDynamicsWorld.h" -@Opaque public static class btSimulationIslandManager extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btSimulationIslandManager() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSimulationIslandManager(Pointer p) { super(p); } -} -@Opaque public static class btPersistentManifold extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btPersistentManifold() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPersistentManifold(Pointer p) { super(p); } -} - -@Opaque public static class InplaceSolverIslandCallback extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public InplaceSolverIslandCallback() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public InplaceSolverIslandCallback(Pointer p) { super(p); } -} - -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btThreads.h" - -/**btDiscreteDynamicsWorld provides discrete rigid body simulation - * those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController */ -@NoOffset public static class btDiscreteDynamicsWorld extends btDynamicsWorld { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDiscreteDynamicsWorld(Pointer p) { super(p); } - - - /**this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those */ - public btDiscreteDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } - private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); - - /**if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's */ - public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); - public native int stepSimulation(@Cast("btScalar") float timeStep); - - public native void solveConstraints(@ByRef btContactSolverInfo solverInfo); - - public native void synchronizeMotionStates(); - - /**this can be useful to synchronize a single rigid body -> graphics object */ - public native void synchronizeSingleMotionState(btRigidBody body); - - public native void addConstraint(btTypedConstraint constraint, @Cast("bool") boolean disableCollisionsBetweenLinkedBodies/*=false*/); - public native void addConstraint(btTypedConstraint constraint); - - public native void removeConstraint(btTypedConstraint constraint); - - public native void addAction(btActionInterface arg0); - - public native void removeAction(btActionInterface arg0); - - public native btSimulationIslandManager getSimulationIslandManager(); - - public native btCollisionWorld getCollisionWorld(); - - public native void setGravity(@Const @ByRef btVector3 gravity); - - public native @ByVal btVector3 getGravity(); - - public native void addCollisionObject(btCollisionObject collisionObject, int collisionFilterGroup/*=btBroadphaseProxy::StaticFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter*/); - public native void addCollisionObject(btCollisionObject collisionObject); - - public native void addRigidBody(btRigidBody body); - - public native void addRigidBody(btRigidBody body, int group, int mask); - - public native void removeRigidBody(btRigidBody body); - - /**removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject */ - public native void removeCollisionObject(btCollisionObject collisionObject); - - public native void debugDrawConstraint(btTypedConstraint constraint); - - public native void debugDrawWorld(); - - public native void setConstraintSolver(btConstraintSolver solver); - - public native btConstraintSolver getConstraintSolver(); - - public native int getNumConstraints(); - - public native btTypedConstraint getConstraint(int index); - - public native @Cast("btDynamicsWorldType") int getWorldType(); - - /**the forces on each rigidbody is accumulating together with gravity. clear this after each timestep. */ - public native void clearForces(); - - /**apply gravity, call this once per timestep */ - public native void applyGravity(); - - public native void setNumTasks(int numTasks); - - /**obsolete, use updateActions instead */ - public native void updateVehicles(@Cast("btScalar") float timeStep); - - /**obsolete, use addAction instead */ - public native void addVehicle(btActionInterface vehicle); - /**obsolete, use removeAction instead */ - public native void removeVehicle(btActionInterface vehicle); - /**obsolete, use addAction instead */ - public native void addCharacter(btActionInterface character); - /**obsolete, use removeAction instead */ - public native void removeCharacter(btActionInterface character); - - public native void setSynchronizeAllMotionStates(@Cast("bool") boolean synchronizeAll); - public native @Cast("bool") boolean getSynchronizeAllMotionStates(); - - public native void setApplySpeculativeContactRestitution(@Cast("bool") boolean enable); - - public native @Cast("bool") boolean getApplySpeculativeContactRestitution(); - - /**Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see Bullet/Demos/SerializeDemo) */ - public native void serialize(btSerializer serializer); - - /**Interpolate motion state between previous and current transform, instead of current and next transform. - * This can relieve discontinuities in the rendering, due to penetrations */ - public native void setLatencyMotionStateInterpolation(@Cast("bool") boolean latencyInterpolation); - public native @Cast("bool") boolean getLatencyMotionStateInterpolation(); - - public native @ByRef btAlignedObjectArray_btRigidBodyPointer getNonStaticRigidBodies(); -} - -// #endif //BT_DISCRETE_DYNAMICS_WORLD_H - - -// Parsed from BulletDynamics/Dynamics/btSimpleDynamicsWorld.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SIMPLE_DYNAMICS_WORLD_H -// #define BT_SIMPLE_DYNAMICS_WORLD_H - -// #include "btDynamicsWorld.h" - -/**The btSimpleDynamicsWorld serves as unit-test and to verify more complicated and optimized dynamics worlds. - * Please use btDiscreteDynamicsWorld instead */ -@NoOffset public static class btSimpleDynamicsWorld extends btDynamicsWorld { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSimpleDynamicsWorld(Pointer p) { super(p); } - - /**this btSimpleDynamicsWorld constructor creates dispatcher, broadphase pairCache and constraintSolver */ - public btSimpleDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } - private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); - - /**maxSubSteps/fixedTimeStep for interpolation is currently ignored for btSimpleDynamicsWorld, use btDiscreteDynamicsWorld instead */ - public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); - public native int stepSimulation(@Cast("btScalar") float timeStep); - - public native void setGravity(@Const @ByRef btVector3 gravity); - - public native @ByVal btVector3 getGravity(); - - public native void addRigidBody(btRigidBody body); - - public native void addRigidBody(btRigidBody body, int group, int mask); - - public native void removeRigidBody(btRigidBody body); - - public native void debugDrawWorld(); - - public native void addAction(btActionInterface action); - - public native void removeAction(btActionInterface action); - - /**removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject */ - public native void removeCollisionObject(btCollisionObject collisionObject); - - public native void updateAabbs(); - - public native void synchronizeMotionStates(); - - public native void setConstraintSolver(btConstraintSolver solver); - - public native btConstraintSolver getConstraintSolver(); - - public native @Cast("btDynamicsWorldType") int getWorldType(); - - public native void clearForces(); -} - -// #endif //BT_SIMPLE_DYNAMICS_WORLD_H - - -// Parsed from BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_POINT2POINTCONSTRAINT_H -// #define BT_POINT2POINTCONSTRAINT_H - -// #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" -// #include "btTypedConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btPoint2PointConstraintData2 btPoint2PointConstraintFloatData -public static final String btPoint2PointConstraintDataName = "btPoint2PointConstraintFloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -@NoOffset public static class btConstraintSetting extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConstraintSetting(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btConstraintSetting(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btConstraintSetting position(long position) { - return (btConstraintSetting)super.position(position); - } - @Override public btConstraintSetting getPointer(long i) { - return new btConstraintSetting((Pointer)this).offsetAddress(i); - } - - public btConstraintSetting() { super((Pointer)null); allocate(); } - private native void allocate(); - public native @Cast("btScalar") float m_tau(); public native btConstraintSetting m_tau(float setter); - public native @Cast("btScalar") float m_damping(); public native btConstraintSetting m_damping(float setter); - public native @Cast("btScalar") float m_impulseClamp(); public native btConstraintSetting m_impulseClamp(float setter); -} - -/** enum btPoint2PointFlags */ -public static final int - BT_P2P_FLAGS_ERP = 1, - BT_P2P_FLAGS_CFM = 2; - -/** point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space */ -@NoOffset public static class btPoint2PointConstraint extends btTypedConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPoint2PointConstraint(Pointer p) { super(p); } - - - /**for backwards compatibility during the transition to 'getInfo/getInfo2' */ - public native @Cast("bool") boolean m_useSolveConstraintObsolete(); public native btPoint2PointConstraint m_useSolveConstraintObsolete(boolean setter); - - public native @ByRef btConstraintSetting m_setting(); public native btPoint2PointConstraint m_setting(btConstraintSetting setter); - - public btPoint2PointConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB); - - public btPoint2PointConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA) { super((Pointer)null); allocate(rbA, pivotInA); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA); - - public native void buildJacobian(); - - public native void updateRHS(@Cast("btScalar") float timeStep); - - public native void setPivotA(@Const @ByRef btVector3 pivotA); - - public native void setPivotB(@Const @ByRef btVector3 pivotB); - - public native @Const @ByRef btVector3 getPivotInA(); - - public native @Const @ByRef btVector3 getPivotInB(); - - /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). - * If no axis is provided, it uses the default axis for this constraint. */ - public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); - public native void setParam(int num, @Cast("btScalar") float value); - /**return the local value of parameter */ - public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); - public native @Cast("btScalar") float getParam(int num); - - public native int getFlags(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btPoint2PointConstraintFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btPoint2PointConstraintFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btPoint2PointConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPoint2PointConstraintFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btPoint2PointConstraintFloatData position(long position) { - return (btPoint2PointConstraintFloatData)super.position(position); - } - @Override public btPoint2PointConstraintFloatData getPointer(long i) { - return new btPoint2PointConstraintFloatData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btVector3FloatData m_pivotInA(); public native btPoint2PointConstraintFloatData m_pivotInA(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_pivotInB(); public native btPoint2PointConstraintFloatData m_pivotInB(btVector3FloatData setter); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btPoint2PointConstraintDoubleData2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btPoint2PointConstraintDoubleData2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btPoint2PointConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPoint2PointConstraintDoubleData2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btPoint2PointConstraintDoubleData2 position(long position) { - return (btPoint2PointConstraintDoubleData2)super.position(position); - } - @Override public btPoint2PointConstraintDoubleData2 getPointer(long i) { - return new btPoint2PointConstraintDoubleData2((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btVector3DoubleData m_pivotInA(); public native btPoint2PointConstraintDoubleData2 m_pivotInA(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_pivotInB(); public native btPoint2PointConstraintDoubleData2 m_pivotInB(btVector3DoubleData setter); -} - -// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 - * this structure is not used, except for loading pre-2.82 .bullet files - * do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btPoint2PointConstraintDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btPoint2PointConstraintDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btPoint2PointConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPoint2PointConstraintDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btPoint2PointConstraintDoubleData position(long position) { - return (btPoint2PointConstraintDoubleData)super.position(position); - } - @Override public btPoint2PointConstraintDoubleData getPointer(long i) { - return new btPoint2PointConstraintDoubleData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btVector3DoubleData m_pivotInA(); public native btPoint2PointConstraintDoubleData m_pivotInA(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_pivotInB(); public native btPoint2PointConstraintDoubleData m_pivotInB(btVector3DoubleData setter); -} -// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_POINT2POINTCONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btHingeConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -/* Hinge Constraint by Dirk Gregorius. Limits added by Marcus Hennix at Starbreeze Studios */ - -// #ifndef BT_HINGECONSTRAINT_H -// #define BT_HINGECONSTRAINT_H - -public static final int _BT_USE_CENTER_LIMIT_ = 1; - -// #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" -// #include "btTypedConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btHingeConstraintData btHingeConstraintFloatData -public static final String btHingeConstraintDataName = "btHingeConstraintFloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -/** enum btHingeFlags */ -public static final int - BT_HINGE_FLAGS_CFM_STOP = 1, - BT_HINGE_FLAGS_ERP_STOP = 2, - BT_HINGE_FLAGS_CFM_NORM = 4, - BT_HINGE_FLAGS_ERP_NORM = 8; - -/** hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space - * axis defines the orientation of the hinge axis */ -@NoOffset public static class btHingeConstraint extends btTypedConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHingeConstraint(Pointer p) { super(p); } - - - public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB, useReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/); - public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); - - public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, pivotInA, axisInA, useReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/); - public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA) { super((Pointer)null); allocate(rbA, pivotInA, axisInA); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA); - - public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); - public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); - - public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbAFrame, useReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); - public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); - - public native void buildJacobian(); - - public native void updateRHS(@Cast("btScalar") float timeStep); - - public native @ByRef btRigidBody getRigidBodyA(); - - public native @ByRef btRigidBody getRigidBodyB(); - - public native @ByRef btTransform getFrameOffsetA(); - - public native @ByRef btTransform getFrameOffsetB(); - - public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); - - public native void setAngularOnly(@Cast("bool") boolean angularOnly); - - public native void enableAngularMotor(@Cast("bool") boolean enableMotor, @Cast("btScalar") float targetVelocity, @Cast("btScalar") float maxMotorImpulse); - - // extra motor API, including ability to set a target rotation (as opposed to angular velocity) - // note: setMotorTarget sets angular velocity under the hood, so you must call it every tick to - // maintain a given angular target. - public native void enableMotor(@Cast("bool") boolean enableMotor); - public native void setMaxMotorImpulse(@Cast("btScalar") float maxMotorImpulse); - public native void setMotorTargetVelocity(@Cast("btScalar") float motorTargetVelocity); - public native void setMotorTarget(@Const @ByRef btQuaternion qAinB, @Cast("btScalar") float dt); // qAinB is rotation of body A wrt body B. - public native void setMotorTarget(@Cast("btScalar") float targetAngle, @Cast("btScalar") float dt); - - public native void setLimit(@Cast("btScalar") float low, @Cast("btScalar") float high, @Cast("btScalar") float _softness/*=0.9f*/, @Cast("btScalar") float _biasFactor/*=0.3f*/, @Cast("btScalar") float _relaxationFactor/*=1.0f*/); - public native void setLimit(@Cast("btScalar") float low, @Cast("btScalar") float high); - - public native @Cast("btScalar") float getLimitSoftness(); - - public native @Cast("btScalar") float getLimitBiasFactor(); - - public native @Cast("btScalar") float getLimitRelaxationFactor(); - - public native void setAxis(@ByRef btVector3 axisInA); - - public native @Cast("bool") boolean hasLimit(); - - public native @Cast("btScalar") float getLowerLimit(); - - public native @Cast("btScalar") float getUpperLimit(); - - /**The getHingeAngle gives the hinge angle in range [-PI,PI] */ - public native @Cast("btScalar") float getHingeAngle(); - - public native @Cast("btScalar") float getHingeAngle(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); - - public native void testLimit(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); - - public native @ByRef btTransform getAFrame(); - public native @ByRef btTransform getBFrame(); - - public native int getSolveLimit(); - - public native @Cast("btScalar") float getLimitSign(); - - public native @Cast("bool") boolean getAngularOnly(); - public native @Cast("bool") boolean getEnableAngularMotor(); - public native @Cast("btScalar") float getMotorTargetVelocity(); - public native @Cast("btScalar") float getMaxMotorImpulse(); - // access for UseFrameOffset - public native @Cast("bool") boolean getUseFrameOffset(); - public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); - // access for UseReferenceFrameA - public native @Cast("bool") boolean getUseReferenceFrameA(); - public native void setUseReferenceFrameA(@Cast("bool") boolean useReferenceFrameA); - - /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). - * If no axis is provided, it uses the default axis for this constraint. */ - public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); - public native void setParam(int num, @Cast("btScalar") float value); - /**return the local value of parameter */ - public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); - public native @Cast("btScalar") float getParam(int num); - - public native int getFlags(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -//only for backward compatibility -// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION -/**this structure is not used, except for loading pre-2.82 .bullet files */ -public static class btHingeConstraintDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btHingeConstraintDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btHingeConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHingeConstraintDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btHingeConstraintDoubleData position(long position) { - return (btHingeConstraintDoubleData)super.position(position); - } - @Override public btHingeConstraintDoubleData getPointer(long i) { - return new btHingeConstraintDoubleData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformDoubleData m_rbAFrame(); public native btHingeConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. - public native @ByRef btTransformDoubleData m_rbBFrame(); public native btHingeConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); - public native int m_useReferenceFrameA(); public native btHingeConstraintDoubleData m_useReferenceFrameA(int setter); - public native int m_angularOnly(); public native btHingeConstraintDoubleData m_angularOnly(int setter); - public native int m_enableAngularMotor(); public native btHingeConstraintDoubleData m_enableAngularMotor(int setter); - public native float m_motorTargetVelocity(); public native btHingeConstraintDoubleData m_motorTargetVelocity(float setter); - public native float m_maxMotorImpulse(); public native btHingeConstraintDoubleData m_maxMotorImpulse(float setter); - - public native float m_lowerLimit(); public native btHingeConstraintDoubleData m_lowerLimit(float setter); - public native float m_upperLimit(); public native btHingeConstraintDoubleData m_upperLimit(float setter); - public native float m_limitSoftness(); public native btHingeConstraintDoubleData m_limitSoftness(float setter); - public native float m_biasFactor(); public native btHingeConstraintDoubleData m_biasFactor(float setter); - public native float m_relaxationFactor(); public native btHingeConstraintDoubleData m_relaxationFactor(float setter); -} -// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION - -/**The getAccumulatedHingeAngle returns the accumulated hinge angle, taking rotation across the -PI/PI boundary into account */ -@NoOffset public static class btHingeAccumulatedAngleConstraint extends btHingeConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHingeAccumulatedAngleConstraint(Pointer p) { super(p); } - - - public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB, useReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/); - public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); - - public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, pivotInA, axisInA, useReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/); - public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA) { super((Pointer)null); allocate(rbA, pivotInA, axisInA); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA); - - public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); - public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); - - public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbAFrame, useReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); - public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); - public native @Cast("btScalar") float getAccumulatedHingeAngle(); - public native void setAccumulatedHingeAngle(@Cast("btScalar") float accAngle); -} - -public static class btHingeConstraintFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btHingeConstraintFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btHingeConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHingeConstraintFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btHingeConstraintFloatData position(long position) { - return (btHingeConstraintFloatData)super.position(position); - } - @Override public btHingeConstraintFloatData getPointer(long i) { - return new btHingeConstraintFloatData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformFloatData m_rbAFrame(); public native btHingeConstraintFloatData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. - public native @ByRef btTransformFloatData m_rbBFrame(); public native btHingeConstraintFloatData m_rbBFrame(btTransformFloatData setter); - public native int m_useReferenceFrameA(); public native btHingeConstraintFloatData m_useReferenceFrameA(int setter); - public native int m_angularOnly(); public native btHingeConstraintFloatData m_angularOnly(int setter); - - public native int m_enableAngularMotor(); public native btHingeConstraintFloatData m_enableAngularMotor(int setter); - public native float m_motorTargetVelocity(); public native btHingeConstraintFloatData m_motorTargetVelocity(float setter); - public native float m_maxMotorImpulse(); public native btHingeConstraintFloatData m_maxMotorImpulse(float setter); - - public native float m_lowerLimit(); public native btHingeConstraintFloatData m_lowerLimit(float setter); - public native float m_upperLimit(); public native btHingeConstraintFloatData m_upperLimit(float setter); - public native float m_limitSoftness(); public native btHingeConstraintFloatData m_limitSoftness(float setter); - public native float m_biasFactor(); public native btHingeConstraintFloatData m_biasFactor(float setter); - public native float m_relaxationFactor(); public native btHingeConstraintFloatData m_relaxationFactor(float setter); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btHingeConstraintDoubleData2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btHingeConstraintDoubleData2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btHingeConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHingeConstraintDoubleData2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btHingeConstraintDoubleData2 position(long position) { - return (btHingeConstraintDoubleData2)super.position(position); - } - @Override public btHingeConstraintDoubleData2 getPointer(long i) { - return new btHingeConstraintDoubleData2((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformDoubleData m_rbAFrame(); public native btHingeConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. - public native @ByRef btTransformDoubleData m_rbBFrame(); public native btHingeConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); - public native int m_useReferenceFrameA(); public native btHingeConstraintDoubleData2 m_useReferenceFrameA(int setter); - public native int m_angularOnly(); public native btHingeConstraintDoubleData2 m_angularOnly(int setter); - public native int m_enableAngularMotor(); public native btHingeConstraintDoubleData2 m_enableAngularMotor(int setter); - public native double m_motorTargetVelocity(); public native btHingeConstraintDoubleData2 m_motorTargetVelocity(double setter); - public native double m_maxMotorImpulse(); public native btHingeConstraintDoubleData2 m_maxMotorImpulse(double setter); - - public native double m_lowerLimit(); public native btHingeConstraintDoubleData2 m_lowerLimit(double setter); - public native double m_upperLimit(); public native btHingeConstraintDoubleData2 m_upperLimit(double setter); - public native double m_limitSoftness(); public native btHingeConstraintDoubleData2 m_limitSoftness(double setter); - public native double m_biasFactor(); public native btHingeConstraintDoubleData2 m_biasFactor(double setter); - public native double m_relaxationFactor(); public native btHingeConstraintDoubleData2 m_relaxationFactor(double setter); - public native @Cast("char") byte m_padding1(int i); public native btHingeConstraintDoubleData2 m_padding1(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding1(); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_HINGECONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btConeTwistConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library -btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. - -Written by: Marcus Hennix -*/ - -/* -Overview: - -btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc). -It is a fixed translation, 3 degree-of-freedom (DOF) rotational "joint". -It divides the 3 rotational DOFs into swing (movement within a cone) and twist. -Swing is divided into swing1 and swing2 which can have different limits, giving an elliptical shape. -(Note: the cone's base isn't flat, so this ellipse is "embedded" on the surface of a sphere.) - -In the contraint's frame of reference: -twist is along the x-axis, -and swing 1 and 2 are along the z and y axes respectively. -*/ - -// #ifndef BT_CONETWISTCONSTRAINT_H -// #define BT_CONETWISTCONSTRAINT_H - -// #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" -// #include "btTypedConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btConeTwistConstraintData2 btConeTwistConstraintData -public static final String btConeTwistConstraintDataName = "btConeTwistConstraintData"; -// #endif //BT_USE_DOUBLE_PRECISION - -/** enum btConeTwistFlags */ -public static final int - BT_CONETWIST_FLAGS_LIN_CFM = 1, - BT_CONETWIST_FLAGS_LIN_ERP = 2, - BT_CONETWIST_FLAGS_ANG_CFM = 4; - -/**btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc) */ -@NoOffset public static class btConeTwistConstraint extends btTypedConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConeTwistConstraint(Pointer p) { super(p); } - - - public btConeTwistConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); - - public btConeTwistConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } - private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); - - public native void buildJacobian(); - - - - public native void updateRHS(@Cast("btScalar") float timeStep); - - public native @Const @ByRef btRigidBody getRigidBodyA(); - public native @Const @ByRef btRigidBody getRigidBodyB(); - - public native void setAngularOnly(@Cast("bool") boolean angularOnly); - - public native @Cast("bool") boolean getAngularOnly(); - - public native void setLimit(int limitIndex, @Cast("btScalar") float limitValue); - - public native @Cast("btScalar") float getLimit(int limitIndex); - - // setLimit(), a few notes: - // _softness: - // 0->1, recommend ~0.8->1. - // describes % of limits where movement is free. - // beyond this softness %, the limit is gradually enforced until the "hard" (1.0) limit is reached. - // _biasFactor: - // 0->1?, recommend 0.3 +/-0.3 or so. - // strength with which constraint resists zeroth order (angular, not angular velocity) limit violation. - // __relaxationFactor: - // 0->1, recommend to stay near 1. - // the lower the value, the less the constraint will fight velocities which violate the angular limits. - public native void setLimit(@Cast("btScalar") float _swingSpan1, @Cast("btScalar") float _swingSpan2, @Cast("btScalar") float _twistSpan, @Cast("btScalar") float _softness/*=1.f*/, @Cast("btScalar") float _biasFactor/*=0.3f*/, @Cast("btScalar") float _relaxationFactor/*=1.0f*/); - public native void setLimit(@Cast("btScalar") float _swingSpan1, @Cast("btScalar") float _swingSpan2, @Cast("btScalar") float _twistSpan); - - public native @Const @ByRef btTransform getAFrame(); - public native @Const @ByRef btTransform getBFrame(); - - public native int getSolveTwistLimit(); - - public native int getSolveSwingLimit(); - - public native @Cast("btScalar") float getTwistLimitSign(); - - public native void calcAngleInfo(); - public native void calcAngleInfo2(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btMatrix3x3 invInertiaWorldA, @Const @ByRef btMatrix3x3 invInertiaWorldB); - - public native @Cast("btScalar") float getSwingSpan1(); - public native @Cast("btScalar") float getSwingSpan2(); - public native @Cast("btScalar") float getTwistSpan(); - public native @Cast("btScalar") float getLimitSoftness(); - public native @Cast("btScalar") float getBiasFactor(); - public native @Cast("btScalar") float getRelaxationFactor(); - public native @Cast("btScalar") float getTwistAngle(); - public native @Cast("bool") boolean isPastSwingLimit(); - - public native @Cast("btScalar") float getDamping(); - public native void setDamping(@Cast("btScalar") float damping); - - public native void enableMotor(@Cast("bool") boolean b); - public native @Cast("bool") boolean isMotorEnabled(); - public native @Cast("btScalar") float getMaxMotorImpulse(); - public native @Cast("bool") boolean isMaxMotorImpulseNormalized(); - public native void setMaxMotorImpulse(@Cast("btScalar") float maxMotorImpulse); - public native void setMaxMotorImpulseNormalized(@Cast("btScalar") float maxMotorImpulse); - - public native @Cast("btScalar") float getFixThresh(); - public native void setFixThresh(@Cast("btScalar") float fixThresh); - - // setMotorTarget: - // q: the desired rotation of bodyA wrt bodyB. - // note: if q violates the joint limits, the internal target is clamped to avoid conflicting impulses (very bad for stability) - // note: don't forget to enableMotor() - public native void setMotorTarget(@Const @ByRef btQuaternion q); - public native @Const @ByRef btQuaternion getMotorTarget(); - - // same as above, but q is the desired rotation of frameA wrt frameB in constraint space - public native void setMotorTargetInConstraintSpace(@Const @ByRef btQuaternion q); - - public native @ByVal btVector3 GetPointForAngle(@Cast("btScalar") float fAngleInRadians, @Cast("btScalar") float fLength); - - /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). - * If no axis is provided, it uses the default axis for this constraint. */ - public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); - public native void setParam(int num, @Cast("btScalar") float value); - - public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); - - public native @Const @ByRef btTransform getFrameOffsetA(); - - public native @Const @ByRef btTransform getFrameOffsetB(); - - /**return the local value of parameter */ - public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); - public native @Cast("btScalar") float getParam(int num); - - public native int getFlags(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -public static class btConeTwistConstraintDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btConeTwistConstraintDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btConeTwistConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConeTwistConstraintDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btConeTwistConstraintDoubleData position(long position) { - return (btConeTwistConstraintDoubleData)super.position(position); - } - @Override public btConeTwistConstraintDoubleData getPointer(long i) { - return new btConeTwistConstraintDoubleData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformDoubleData m_rbAFrame(); public native btConeTwistConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); - public native @ByRef btTransformDoubleData m_rbBFrame(); public native btConeTwistConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); - - //limits - public native double m_swingSpan1(); public native btConeTwistConstraintDoubleData m_swingSpan1(double setter); - public native double m_swingSpan2(); public native btConeTwistConstraintDoubleData m_swingSpan2(double setter); - public native double m_twistSpan(); public native btConeTwistConstraintDoubleData m_twistSpan(double setter); - public native double m_limitSoftness(); public native btConeTwistConstraintDoubleData m_limitSoftness(double setter); - public native double m_biasFactor(); public native btConeTwistConstraintDoubleData m_biasFactor(double setter); - public native double m_relaxationFactor(); public native btConeTwistConstraintDoubleData m_relaxationFactor(double setter); - - public native double m_damping(); public native btConeTwistConstraintDoubleData m_damping(double setter); -} - -// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION -/**this structure is not used, except for loading pre-2.82 .bullet files */ -public static class btConeTwistConstraintData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btConeTwistConstraintData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btConeTwistConstraintData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConeTwistConstraintData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btConeTwistConstraintData position(long position) { - return (btConeTwistConstraintData)super.position(position); - } - @Override public btConeTwistConstraintData getPointer(long i) { - return new btConeTwistConstraintData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformFloatData m_rbAFrame(); public native btConeTwistConstraintData m_rbAFrame(btTransformFloatData setter); - public native @ByRef btTransformFloatData m_rbBFrame(); public native btConeTwistConstraintData m_rbBFrame(btTransformFloatData setter); - - //limits - public native float m_swingSpan1(); public native btConeTwistConstraintData m_swingSpan1(float setter); - public native float m_swingSpan2(); public native btConeTwistConstraintData m_swingSpan2(float setter); - public native float m_twistSpan(); public native btConeTwistConstraintData m_twistSpan(float setter); - public native float m_limitSoftness(); public native btConeTwistConstraintData m_limitSoftness(float setter); - public native float m_biasFactor(); public native btConeTwistConstraintData m_biasFactor(float setter); - public native float m_relaxationFactor(); public native btConeTwistConstraintData m_relaxationFactor(float setter); - - public native float m_damping(); public native btConeTwistConstraintData m_damping(float setter); - - public native @Cast("char") byte m_pad(int i); public native btConeTwistConstraintData m_pad(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_pad(); -} -// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION -// - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_CONETWISTCONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev -/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ - -/* -2007-09-09 -btGeneric6DofConstraint Refactored by Francisco Le?n -email: projectileman@yahoo.com -http://gimpact.sf.net -*/ - -// #ifndef BT_GENERIC_6DOF_CONSTRAINT_H -// #define BT_GENERIC_6DOF_CONSTRAINT_H - -// #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" -// #include "btTypedConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btGeneric6DofConstraintData2 btGeneric6DofConstraintData -public static final String btGeneric6DofConstraintDataName = "btGeneric6DofConstraintData"; -// #endif //BT_USE_DOUBLE_PRECISION - -/** Rotation Limit structure for generic joints */ -@NoOffset public static class btRotationalLimitMotor extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRotationalLimitMotor(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btRotationalLimitMotor(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btRotationalLimitMotor position(long position) { - return (btRotationalLimitMotor)super.position(position); - } - @Override public btRotationalLimitMotor getPointer(long i) { - return new btRotationalLimitMotor((Pointer)this).offsetAddress(i); - } - - /** limit_parameters - * \{ */ - /** joint limit */ - public native @Cast("btScalar") float m_loLimit(); public native btRotationalLimitMotor m_loLimit(float setter); - /** joint limit */ - public native @Cast("btScalar") float m_hiLimit(); public native btRotationalLimitMotor m_hiLimit(float setter); - /** target motor velocity */ - public native @Cast("btScalar") float m_targetVelocity(); public native btRotationalLimitMotor m_targetVelocity(float setter); - /** max force on motor */ - public native @Cast("btScalar") float m_maxMotorForce(); public native btRotationalLimitMotor m_maxMotorForce(float setter); - /** max force on limit */ - public native @Cast("btScalar") float m_maxLimitForce(); public native btRotationalLimitMotor m_maxLimitForce(float setter); - /** Damping. */ - public native @Cast("btScalar") float m_damping(); public native btRotationalLimitMotor m_damping(float setter); - public native @Cast("btScalar") float m_limitSoftness(); public native btRotationalLimitMotor m_limitSoftness(float setter); /** Relaxation factor */ - /** Constraint force mixing factor */ - public native @Cast("btScalar") float m_normalCFM(); public native btRotationalLimitMotor m_normalCFM(float setter); - /** Error tolerance factor when joint is at limit */ - public native @Cast("btScalar") float m_stopERP(); public native btRotationalLimitMotor m_stopERP(float setter); - /** Constraint force mixing factor when joint is at limit */ - public native @Cast("btScalar") float m_stopCFM(); public native btRotationalLimitMotor m_stopCFM(float setter); - /** restitution factor */ - public native @Cast("btScalar") float m_bounce(); public native btRotationalLimitMotor m_bounce(float setter); - public native @Cast("bool") boolean m_enableMotor(); public native btRotationalLimitMotor m_enableMotor(boolean setter); - - /**\} -

- * temp_variables - * \{ */ - public native @Cast("btScalar") float m_currentLimitError(); public native btRotationalLimitMotor m_currentLimitError(float setter); /** How much is violated this limit */ - public native @Cast("btScalar") float m_currentPosition(); public native btRotationalLimitMotor m_currentPosition(float setter); /** current value of angle */ - /** 0=free, 1=at lo limit, 2=at hi limit */ - public native int m_currentLimit(); public native btRotationalLimitMotor m_currentLimit(int setter); - public native @Cast("btScalar") float m_accumulatedImpulse(); public native btRotationalLimitMotor m_accumulatedImpulse(float setter); - /**\} */ - - public btRotationalLimitMotor() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btRotationalLimitMotor(@Const @ByRef btRotationalLimitMotor limot) { super((Pointer)null); allocate(limot); } - private native void allocate(@Const @ByRef btRotationalLimitMotor limot); - - /** Is limited */ - public native @Cast("bool") boolean isLimited(); - - /** Need apply correction */ - public native @Cast("bool") boolean needApplyTorques(); - - /** calculates error - /** - calculates m_currentLimit and m_currentLimitError. - */ - public native int testLimitValue(@Cast("btScalar") float test_value); - - /** apply the correction impulses for two bodies */ - public native @Cast("btScalar") float solveAngularLimits(@Cast("btScalar") float timeStep, @ByRef btVector3 axis, @Cast("btScalar") float jacDiagABInv, btRigidBody body0, btRigidBody body1); -} - -@NoOffset public static class btTranslationalLimitMotor extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTranslationalLimitMotor(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTranslationalLimitMotor(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btTranslationalLimitMotor position(long position) { - return (btTranslationalLimitMotor)super.position(position); - } - @Override public btTranslationalLimitMotor getPointer(long i) { - return new btTranslationalLimitMotor((Pointer)this).offsetAddress(i); - } - - /** the constraint lower limits */ - public native @ByRef btVector3 m_lowerLimit(); public native btTranslationalLimitMotor m_lowerLimit(btVector3 setter); - /** the constraint upper limits */ - public native @ByRef btVector3 m_upperLimit(); public native btTranslationalLimitMotor m_upperLimit(btVector3 setter); - public native @ByRef btVector3 m_accumulatedImpulse(); public native btTranslationalLimitMotor m_accumulatedImpulse(btVector3 setter); - /** Linear_Limit_parameters - * \{ */ - /** Softness for linear limit */ - public native @Cast("btScalar") float m_limitSoftness(); public native btTranslationalLimitMotor m_limitSoftness(float setter); - /** Damping for linear limit */ - public native @Cast("btScalar") float m_damping(); public native btTranslationalLimitMotor m_damping(float setter); - public native @Cast("btScalar") float m_restitution(); public native btTranslationalLimitMotor m_restitution(float setter); /** Bounce parameter for linear limit */ - /** Constraint force mixing factor */ - public native @ByRef btVector3 m_normalCFM(); public native btTranslationalLimitMotor m_normalCFM(btVector3 setter); - /** Error tolerance factor when joint is at limit */ - public native @ByRef btVector3 m_stopERP(); public native btTranslationalLimitMotor m_stopERP(btVector3 setter); - /** Constraint force mixing factor when joint is at limit */ - public native @ByRef btVector3 m_stopCFM(); public native btTranslationalLimitMotor m_stopCFM(btVector3 setter); - /**\} */ - public native @Cast("bool") boolean m_enableMotor(int i); public native btTranslationalLimitMotor m_enableMotor(int i, boolean setter); - @MemberGetter public native @Cast("bool*") BoolPointer m_enableMotor(); - /** target motor velocity */ - public native @ByRef btVector3 m_targetVelocity(); public native btTranslationalLimitMotor m_targetVelocity(btVector3 setter); - /** max force on motor */ - public native @ByRef btVector3 m_maxMotorForce(); public native btTranslationalLimitMotor m_maxMotorForce(btVector3 setter); - public native @ByRef btVector3 m_currentLimitError(); public native btTranslationalLimitMotor m_currentLimitError(btVector3 setter); /** How much is violated this limit */ - public native @ByRef btVector3 m_currentLinearDiff(); public native btTranslationalLimitMotor m_currentLinearDiff(btVector3 setter); /** Current relative offset of constraint frames */ - /** 0=free, 1=at lower limit, 2=at upper limit */ - public native int m_currentLimit(int i); public native btTranslationalLimitMotor m_currentLimit(int i, int setter); - @MemberGetter public native IntPointer m_currentLimit(); - - public btTranslationalLimitMotor() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btTranslationalLimitMotor(@Const @ByRef btTranslationalLimitMotor other) { super((Pointer)null); allocate(other); } - private native void allocate(@Const @ByRef btTranslationalLimitMotor other); - - /** Test limit - /** - - free means upper < lower, - - locked means upper == lower - - limited means upper > lower - - limitIndex: first 3 are linear, next 3 are angular - */ - public native @Cast("bool") boolean isLimited(int limitIndex); - public native @Cast("bool") boolean needApplyForce(int limitIndex); - public native int testLimitValue(int limitIndex, @Cast("btScalar") float test_value); - - public native @Cast("btScalar") float solveLinearAxis( - @Cast("btScalar") float timeStep, - @Cast("btScalar") float jacDiagABInv, - @ByRef btRigidBody body1, @Const @ByRef btVector3 pointInA, - @ByRef btRigidBody body2, @Const @ByRef btVector3 pointInB, - int limit_index, - @Const @ByRef btVector3 axis_normal_on_a, - @Const @ByRef btVector3 anchorPos); -} - -/** enum bt6DofFlags */ -public static final int - BT_6DOF_FLAGS_CFM_NORM = 1, - BT_6DOF_FLAGS_CFM_STOP = 2, - BT_6DOF_FLAGS_ERP_STOP = 4; -public static final int BT_6DOF_FLAGS_AXIS_SHIFT = 3; // bits per axis - -/** btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space -/** -btGeneric6DofConstraint can leave any of the 6 degree of freedom 'free' or 'locked'. -currently this limit supports rotational motors
-

    -
  • For Linear limits, use btGeneric6DofConstraint.setLinearUpperLimit, btGeneric6DofConstraint.setLinearLowerLimit. You can set the parameters with the btTranslationalLimitMotor structure accsesible through the btGeneric6DofConstraint.getTranslationalLimitMotor method. -At this moment translational motors are not supported. May be in the future.
    • -

    -

  • For Angular limits, use the btRotationalLimitMotor structure for configuring the limit. -This is accessible through btGeneric6DofConstraint.getLimitMotor method, -This brings support for limit parameters and motors.
    • -

    -

  • Angulars limits have these possible ranges: - - - - - - - - - - - - - - - - - - -
    AXISMIN ANGLEMAX ANGLE
    X-PIPI
    Y-PI/2PI/2
    Z-PIPI
    -
    • -
-

-*/ -@NoOffset public static class btGeneric6DofConstraint extends btTypedConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofConstraint(Pointer p) { super(p); } - - - /**for backwards compatibility during the transition to 'getInfo/getInfo2' */ - public native @Cast("bool") boolean m_useSolveConstraintObsolete(); public native btGeneric6DofConstraint m_useSolveConstraintObsolete(boolean setter); - - public btGeneric6DofConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); - public btGeneric6DofConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameB); } - private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB); - - /** Calcs global transform of the offsets - /** - Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies. - @see btGeneric6DofConstraint.getCalculatedTransformA , btGeneric6DofConstraint.getCalculatedTransformB, btGeneric6DofConstraint.calculateAngleInfo - */ - public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); - - public native void calculateTransforms(); - - /** Gets the global transform of the offset for body A - /** - @see btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo. - */ - public native @Const @ByRef btTransform getCalculatedTransformA(); - - /** Gets the global transform of the offset for body B - /** - @see btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo. - */ - public native @Const @ByRef btTransform getCalculatedTransformB(); - - public native @ByRef btTransform getFrameOffsetA(); - - public native @ByRef btTransform getFrameOffsetB(); - - /** performs Jacobian calculation, and also calculates angle differences and axis */ - public native void buildJacobian(); - - public native void updateRHS(@Cast("btScalar") float timeStep); - - /** Get the rotation axis in global coordinates - /** - \pre btGeneric6DofConstraint.buildJacobian must be called previously. - */ - public native @ByVal btVector3 getAxis(int axis_index); - - /** Get the relative Euler angle - /** - \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. - */ - public native @Cast("btScalar") float getAngle(int axis_index); - - /** Get the relative position of the constraint pivot - /** - \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. - */ - public native @Cast("btScalar") float getRelativePivotPosition(int axis_index); - - public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); - - /** Test angular limit. - /** - Calculates angular correction and returns true if limit needs to be corrected. - \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. - */ - public native @Cast("bool") boolean testAngularLimitMotor(int axis_index); - - public native void setLinearLowerLimit(@Const @ByRef btVector3 linearLower); - - public native void getLinearLowerLimit(@ByRef btVector3 linearLower); - - public native void setLinearUpperLimit(@Const @ByRef btVector3 linearUpper); - - public native void getLinearUpperLimit(@ByRef btVector3 linearUpper); - - public native void setAngularLowerLimit(@Const @ByRef btVector3 angularLower); - - public native void getAngularLowerLimit(@ByRef btVector3 angularLower); - - public native void setAngularUpperLimit(@Const @ByRef btVector3 angularUpper); - - public native void getAngularUpperLimit(@ByRef btVector3 angularUpper); - - /** Retrieves the angular limit informacion */ - public native btRotationalLimitMotor getRotationalLimitMotor(int index); - - /** Retrieves the limit informacion */ - public native btTranslationalLimitMotor getTranslationalLimitMotor(); - - //first 3 are linear, next 3 are angular - public native void setLimit(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); - - /** Test limit - /** - - free means upper < lower, - - locked means upper == lower - - limited means upper > lower - - limitIndex: first 3 are linear, next 3 are angular - */ - public native @Cast("bool") boolean isLimited(int limitIndex); - - public native void calcAnchorPos(); // overridable - - // access for UseFrameOffset - public native @Cast("bool") boolean getUseFrameOffset(); - public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); - - public native @Cast("bool") boolean getUseLinearReferenceFrameA(); - public native void setUseLinearReferenceFrameA(@Cast("bool") boolean linearReferenceFrameA); - - /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). - * If no axis is provided, it uses the default axis for this constraint. */ - public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); - public native void setParam(int num, @Cast("btScalar") float value); - /**return the local value of parameter */ - public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); - public native @Cast("btScalar") float getParam(int num); - - public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); - - public native int getFlags(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -public static class btGeneric6DofConstraintData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btGeneric6DofConstraintData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btGeneric6DofConstraintData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofConstraintData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btGeneric6DofConstraintData position(long position) { - return (btGeneric6DofConstraintData)super.position(position); - } - @Override public btGeneric6DofConstraintData getPointer(long i) { - return new btGeneric6DofConstraintData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformFloatData m_rbAFrame(); public native btGeneric6DofConstraintData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. - public native @ByRef btTransformFloatData m_rbBFrame(); public native btGeneric6DofConstraintData m_rbBFrame(btTransformFloatData setter); - - public native @ByRef btVector3FloatData m_linearUpperLimit(); public native btGeneric6DofConstraintData m_linearUpperLimit(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearLowerLimit(); public native btGeneric6DofConstraintData m_linearLowerLimit(btVector3FloatData setter); - - public native @ByRef btVector3FloatData m_angularUpperLimit(); public native btGeneric6DofConstraintData m_angularUpperLimit(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularLowerLimit(); public native btGeneric6DofConstraintData m_angularLowerLimit(btVector3FloatData setter); - - public native int m_useLinearReferenceFrameA(); public native btGeneric6DofConstraintData m_useLinearReferenceFrameA(int setter); - public native int m_useOffsetForConstraintFrame(); public native btGeneric6DofConstraintData m_useOffsetForConstraintFrame(int setter); -} - -public static class btGeneric6DofConstraintDoubleData2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btGeneric6DofConstraintDoubleData2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btGeneric6DofConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofConstraintDoubleData2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btGeneric6DofConstraintDoubleData2 position(long position) { - return (btGeneric6DofConstraintDoubleData2)super.position(position); - } - @Override public btGeneric6DofConstraintDoubleData2 getPointer(long i) { - return new btGeneric6DofConstraintDoubleData2((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformDoubleData m_rbAFrame(); public native btGeneric6DofConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. - public native @ByRef btTransformDoubleData m_rbBFrame(); public native btGeneric6DofConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); - - public native @ByRef btVector3DoubleData m_linearUpperLimit(); public native btGeneric6DofConstraintDoubleData2 m_linearUpperLimit(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearLowerLimit(); public native btGeneric6DofConstraintDoubleData2 m_linearLowerLimit(btVector3DoubleData setter); - - public native @ByRef btVector3DoubleData m_angularUpperLimit(); public native btGeneric6DofConstraintDoubleData2 m_angularUpperLimit(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularLowerLimit(); public native btGeneric6DofConstraintDoubleData2 m_angularLowerLimit(btVector3DoubleData setter); - - public native int m_useLinearReferenceFrameA(); public native btGeneric6DofConstraintDoubleData2 m_useLinearReferenceFrameA(int setter); - public native int m_useOffsetForConstraintFrame(); public native btGeneric6DofConstraintDoubleData2 m_useOffsetForConstraintFrame(int setter); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_GENERIC_6DOF_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btSliderConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -/* -Added by Roman Ponomarev (rponom@gmail.com) -April 04, 2008 - -TODO: - - add clamping od accumulated impulse to improve stability - - add conversion for ODE constraint solver -*/ - -// #ifndef BT_SLIDER_CONSTRAINT_H -// #define BT_SLIDER_CONSTRAINT_H - -// #include "LinearMath/btScalar.h" //for BT_USE_DOUBLE_PRECISION - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btSliderConstraintData2 btSliderConstraintData -public static final String btSliderConstraintDataName = "btSliderConstraintData"; -// #endif //BT_USE_DOUBLE_PRECISION - -// #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" -// #include "btTypedConstraint.h" - -public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_SOFTNESS(); -public static final double SLIDER_CONSTRAINT_DEF_SOFTNESS = SLIDER_CONSTRAINT_DEF_SOFTNESS(); -public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_DAMPING(); -public static final double SLIDER_CONSTRAINT_DEF_DAMPING = SLIDER_CONSTRAINT_DEF_DAMPING(); -public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_RESTITUTION(); -public static final double SLIDER_CONSTRAINT_DEF_RESTITUTION = SLIDER_CONSTRAINT_DEF_RESTITUTION(); -public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_CFM(); -public static final double SLIDER_CONSTRAINT_DEF_CFM = SLIDER_CONSTRAINT_DEF_CFM(); - -/** enum btSliderFlags */ -public static final int - BT_SLIDER_FLAGS_CFM_DIRLIN = (1 << 0), - BT_SLIDER_FLAGS_ERP_DIRLIN = (1 << 1), - BT_SLIDER_FLAGS_CFM_DIRANG = (1 << 2), - BT_SLIDER_FLAGS_ERP_DIRANG = (1 << 3), - BT_SLIDER_FLAGS_CFM_ORTLIN = (1 << 4), - BT_SLIDER_FLAGS_ERP_ORTLIN = (1 << 5), - BT_SLIDER_FLAGS_CFM_ORTANG = (1 << 6), - BT_SLIDER_FLAGS_ERP_ORTANG = (1 << 7), - BT_SLIDER_FLAGS_CFM_LIMLIN = (1 << 8), - BT_SLIDER_FLAGS_ERP_LIMLIN = (1 << 9), - BT_SLIDER_FLAGS_CFM_LIMANG = (1 << 10), - BT_SLIDER_FLAGS_ERP_LIMANG = (1 << 11); - -@NoOffset public static class btSliderConstraint extends btTypedConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSliderConstraint(Pointer p) { super(p); } - - - // constructors - public btSliderConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); - public btSliderConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); - - // overrides - - // access - public native @Const @ByRef btRigidBody getRigidBodyA(); - public native @Const @ByRef btRigidBody getRigidBodyB(); - public native @Const @ByRef btTransform getCalculatedTransformA(); - public native @Const @ByRef btTransform getCalculatedTransformB(); - public native @ByRef btTransform getFrameOffsetA(); - public native @ByRef btTransform getFrameOffsetB(); - public native @Cast("btScalar") float getLowerLinLimit(); - public native void setLowerLinLimit(@Cast("btScalar") float lowerLimit); - public native @Cast("btScalar") float getUpperLinLimit(); - public native void setUpperLinLimit(@Cast("btScalar") float upperLimit); - public native @Cast("btScalar") float getLowerAngLimit(); - public native void setLowerAngLimit(@Cast("btScalar") float lowerLimit); - public native @Cast("btScalar") float getUpperAngLimit(); - public native void setUpperAngLimit(@Cast("btScalar") float upperLimit); - public native @Cast("bool") boolean getUseLinearReferenceFrameA(); - public native @Cast("btScalar") float getSoftnessDirLin(); - public native @Cast("btScalar") float getRestitutionDirLin(); - public native @Cast("btScalar") float getDampingDirLin(); - public native @Cast("btScalar") float getSoftnessDirAng(); - public native @Cast("btScalar") float getRestitutionDirAng(); - public native @Cast("btScalar") float getDampingDirAng(); - public native @Cast("btScalar") float getSoftnessLimLin(); - public native @Cast("btScalar") float getRestitutionLimLin(); - public native @Cast("btScalar") float getDampingLimLin(); - public native @Cast("btScalar") float getSoftnessLimAng(); - public native @Cast("btScalar") float getRestitutionLimAng(); - public native @Cast("btScalar") float getDampingLimAng(); - public native @Cast("btScalar") float getSoftnessOrthoLin(); - public native @Cast("btScalar") float getRestitutionOrthoLin(); - public native @Cast("btScalar") float getDampingOrthoLin(); - public native @Cast("btScalar") float getSoftnessOrthoAng(); - public native @Cast("btScalar") float getRestitutionOrthoAng(); - public native @Cast("btScalar") float getDampingOrthoAng(); - public native void setSoftnessDirLin(@Cast("btScalar") float softnessDirLin); - public native void setRestitutionDirLin(@Cast("btScalar") float restitutionDirLin); - public native void setDampingDirLin(@Cast("btScalar") float dampingDirLin); - public native void setSoftnessDirAng(@Cast("btScalar") float softnessDirAng); - public native void setRestitutionDirAng(@Cast("btScalar") float restitutionDirAng); - public native void setDampingDirAng(@Cast("btScalar") float dampingDirAng); - public native void setSoftnessLimLin(@Cast("btScalar") float softnessLimLin); - public native void setRestitutionLimLin(@Cast("btScalar") float restitutionLimLin); - public native void setDampingLimLin(@Cast("btScalar") float dampingLimLin); - public native void setSoftnessLimAng(@Cast("btScalar") float softnessLimAng); - public native void setRestitutionLimAng(@Cast("btScalar") float restitutionLimAng); - public native void setDampingLimAng(@Cast("btScalar") float dampingLimAng); - public native void setSoftnessOrthoLin(@Cast("btScalar") float softnessOrthoLin); - public native void setRestitutionOrthoLin(@Cast("btScalar") float restitutionOrthoLin); - public native void setDampingOrthoLin(@Cast("btScalar") float dampingOrthoLin); - public native void setSoftnessOrthoAng(@Cast("btScalar") float softnessOrthoAng); - public native void setRestitutionOrthoAng(@Cast("btScalar") float restitutionOrthoAng); - public native void setDampingOrthoAng(@Cast("btScalar") float dampingOrthoAng); - public native void setPoweredLinMotor(@Cast("bool") boolean onOff); - public native @Cast("bool") boolean getPoweredLinMotor(); - public native void setTargetLinMotorVelocity(@Cast("btScalar") float targetLinMotorVelocity); - public native @Cast("btScalar") float getTargetLinMotorVelocity(); - public native void setMaxLinMotorForce(@Cast("btScalar") float maxLinMotorForce); - public native @Cast("btScalar") float getMaxLinMotorForce(); - public native void setPoweredAngMotor(@Cast("bool") boolean onOff); - public native @Cast("bool") boolean getPoweredAngMotor(); - public native void setTargetAngMotorVelocity(@Cast("btScalar") float targetAngMotorVelocity); - public native @Cast("btScalar") float getTargetAngMotorVelocity(); - public native void setMaxAngMotorForce(@Cast("btScalar") float maxAngMotorForce); - public native @Cast("btScalar") float getMaxAngMotorForce(); - - public native @Cast("btScalar") float getLinearPos(); - public native @Cast("btScalar") float getAngularPos(); - - // access for ODE solver - public native @Cast("bool") boolean getSolveLinLimit(); - public native @Cast("btScalar") float getLinDepth(); - public native @Cast("bool") boolean getSolveAngLimit(); - public native @Cast("btScalar") float getAngDepth(); - // shared code used by ODE solver - public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); - public native void testLinLimits(); - public native void testAngLimits(); - // access for PE Solver - public native @ByVal btVector3 getAncorInA(); - public native @ByVal btVector3 getAncorInB(); - // access for UseFrameOffset - public native @Cast("bool") boolean getUseFrameOffset(); - public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); - - public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); - - /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). - * If no axis is provided, it uses the default axis for this constraint. */ - public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); - public native void setParam(int num, @Cast("btScalar") float value); - /**return the local value of parameter */ - public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); - public native @Cast("btScalar") float getParam(int num); - - public native int getFlags(); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ - -public static class btSliderConstraintData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btSliderConstraintData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btSliderConstraintData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSliderConstraintData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btSliderConstraintData position(long position) { - return (btSliderConstraintData)super.position(position); - } - @Override public btSliderConstraintData getPointer(long i) { - return new btSliderConstraintData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformFloatData m_rbAFrame(); public native btSliderConstraintData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. - public native @ByRef btTransformFloatData m_rbBFrame(); public native btSliderConstraintData m_rbBFrame(btTransformFloatData setter); - - public native float m_linearUpperLimit(); public native btSliderConstraintData m_linearUpperLimit(float setter); - public native float m_linearLowerLimit(); public native btSliderConstraintData m_linearLowerLimit(float setter); - - public native float m_angularUpperLimit(); public native btSliderConstraintData m_angularUpperLimit(float setter); - public native float m_angularLowerLimit(); public native btSliderConstraintData m_angularLowerLimit(float setter); - - public native int m_useLinearReferenceFrameA(); public native btSliderConstraintData m_useLinearReferenceFrameA(int setter); - public native int m_useOffsetForConstraintFrame(); public native btSliderConstraintData m_useOffsetForConstraintFrame(int setter); -} - -public static class btSliderConstraintDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btSliderConstraintDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btSliderConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSliderConstraintDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btSliderConstraintDoubleData position(long position) { - return (btSliderConstraintDoubleData)super.position(position); - } - @Override public btSliderConstraintDoubleData getPointer(long i) { - return new btSliderConstraintDoubleData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformDoubleData m_rbAFrame(); public native btSliderConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. - public native @ByRef btTransformDoubleData m_rbBFrame(); public native btSliderConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); - - public native double m_linearUpperLimit(); public native btSliderConstraintDoubleData m_linearUpperLimit(double setter); - public native double m_linearLowerLimit(); public native btSliderConstraintDoubleData m_linearLowerLimit(double setter); - - public native double m_angularUpperLimit(); public native btSliderConstraintDoubleData m_angularUpperLimit(double setter); - public native double m_angularLowerLimit(); public native btSliderConstraintDoubleData m_angularLowerLimit(double setter); - - public native int m_useLinearReferenceFrameA(); public native btSliderConstraintDoubleData m_useLinearReferenceFrameA(int setter); - public native int m_useOffsetForConstraintFrame(); public native btSliderConstraintDoubleData m_useOffsetForConstraintFrame(int setter); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_SLIDER_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org -Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H -// #define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H - -// #include "LinearMath/btVector3.h" -// #include "btTypedConstraint.h" -// #include "btGeneric6DofConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData -public static final String btGeneric6DofSpringConstraintDataName = "btGeneric6DofSpringConstraintData"; -// #endif //BT_USE_DOUBLE_PRECISION - -/** Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF -

- * DOF index used in enableSpring() and setStiffness() means: - * 0 : translation X - * 1 : translation Y - * 2 : translation Z - * 3 : rotation X (3rd Euler rotational around new position of X axis, range [-PI+epsilon, PI-epsilon] ) - * 4 : rotation Y (2nd Euler rotational around new position of Y axis, range [-PI/2+epsilon, PI/2-epsilon] ) - * 5 : rotation Z (1st Euler rotational around Z axis, range [-PI+epsilon, PI-epsilon] ) */ - -@NoOffset public static class btGeneric6DofSpringConstraint extends btGeneric6DofConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofSpringConstraint(Pointer p) { super(p); } - - - public btGeneric6DofSpringConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); - public btGeneric6DofSpringConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameB); } - private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB); - public native void enableSpring(int index, @Cast("bool") boolean onOff); - public native void setStiffness(int index, @Cast("btScalar") float stiffness); - public native void setDamping(int index, @Cast("btScalar") float damping); - public native void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF - public native void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF - public native void setEquilibriumPoint(int index, @Cast("btScalar") float val); - - public native @Cast("bool") boolean isSpringEnabled(int index); - - public native @Cast("btScalar") float getStiffness(int index); - - public native @Cast("btScalar") float getDamping(int index); - - public native @Cast("btScalar") float getEquilibriumPoint(int index); - - public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); - - public native int calculateSerializeBufferSize(); - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -public static class btGeneric6DofSpringConstraintData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btGeneric6DofSpringConstraintData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btGeneric6DofSpringConstraintData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofSpringConstraintData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btGeneric6DofSpringConstraintData position(long position) { - return (btGeneric6DofSpringConstraintData)super.position(position); - } - @Override public btGeneric6DofSpringConstraintData getPointer(long i) { - return new btGeneric6DofSpringConstraintData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btGeneric6DofConstraintData m_6dofData(); public native btGeneric6DofSpringConstraintData m_6dofData(btGeneric6DofConstraintData setter); - - public native int m_springEnabled(int i); public native btGeneric6DofSpringConstraintData m_springEnabled(int i, int setter); - @MemberGetter public native IntPointer m_springEnabled(); - public native float m_equilibriumPoint(int i); public native btGeneric6DofSpringConstraintData m_equilibriumPoint(int i, float setter); - @MemberGetter public native FloatPointer m_equilibriumPoint(); - public native float m_springStiffness(int i); public native btGeneric6DofSpringConstraintData m_springStiffness(int i, float setter); - @MemberGetter public native FloatPointer m_springStiffness(); - public native float m_springDamping(int i); public native btGeneric6DofSpringConstraintData m_springDamping(int i, float setter); - @MemberGetter public native FloatPointer m_springDamping(); -} - -public static class btGeneric6DofSpringConstraintDoubleData2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btGeneric6DofSpringConstraintDoubleData2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btGeneric6DofSpringConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofSpringConstraintDoubleData2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btGeneric6DofSpringConstraintDoubleData2 position(long position) { - return (btGeneric6DofSpringConstraintDoubleData2)super.position(position); - } - @Override public btGeneric6DofSpringConstraintDoubleData2 getPointer(long i) { - return new btGeneric6DofSpringConstraintDoubleData2((Pointer)this).offsetAddress(i); - } - - public native @ByRef btGeneric6DofConstraintDoubleData2 m_6dofData(); public native btGeneric6DofSpringConstraintDoubleData2 m_6dofData(btGeneric6DofConstraintDoubleData2 setter); - - public native int m_springEnabled(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springEnabled(int i, int setter); - @MemberGetter public native IntPointer m_springEnabled(); - public native double m_equilibriumPoint(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_equilibriumPoint(int i, double setter); - @MemberGetter public native DoublePointer m_equilibriumPoint(); - public native double m_springStiffness(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springStiffness(int i, double setter); - @MemberGetter public native DoublePointer m_springStiffness(); - public native double m_springDamping(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springDamping(int i, double setter); - @MemberGetter public native DoublePointer m_springDamping(); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -/* -2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer -Pros: -- Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled) -- Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring) -- Servo motor functionality -- Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision) -- Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2) - -Cons: -- It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation. -- At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.) -*/ - -/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev -/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ - -/* -2007-09-09 -btGeneric6DofConstraint Refactored by Francisco Le?n -email: projectileman@yahoo.com -http://gimpact.sf.net -*/ - -// #ifndef BT_GENERIC_6DOF_CONSTRAINT2_H -// #define BT_GENERIC_6DOF_CONSTRAINT2_H - -// #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" -// #include "btTypedConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData -public static final String btGeneric6DofSpring2ConstraintDataName = "btGeneric6DofSpring2ConstraintData"; -// #endif //BT_USE_DOUBLE_PRECISION - -/** enum RotateOrder */ -public static final int - RO_XYZ = 0, - RO_XZY = 1, - RO_YXZ = 2, - RO_YZX = 3, - RO_ZXY = 4, - RO_ZYX = 5; - -@NoOffset public static class btRotationalLimitMotor2 extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRotationalLimitMotor2(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btRotationalLimitMotor2(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btRotationalLimitMotor2 position(long position) { - return (btRotationalLimitMotor2)super.position(position); - } - @Override public btRotationalLimitMotor2 getPointer(long i) { - return new btRotationalLimitMotor2((Pointer)this).offsetAddress(i); - } - - // upper < lower means free - // upper == lower means locked - // upper > lower means limited - public native @Cast("btScalar") float m_loLimit(); public native btRotationalLimitMotor2 m_loLimit(float setter); - public native @Cast("btScalar") float m_hiLimit(); public native btRotationalLimitMotor2 m_hiLimit(float setter); - public native @Cast("btScalar") float m_bounce(); public native btRotationalLimitMotor2 m_bounce(float setter); - public native @Cast("btScalar") float m_stopERP(); public native btRotationalLimitMotor2 m_stopERP(float setter); - public native @Cast("btScalar") float m_stopCFM(); public native btRotationalLimitMotor2 m_stopCFM(float setter); - public native @Cast("btScalar") float m_motorERP(); public native btRotationalLimitMotor2 m_motorERP(float setter); - public native @Cast("btScalar") float m_motorCFM(); public native btRotationalLimitMotor2 m_motorCFM(float setter); - public native @Cast("bool") boolean m_enableMotor(); public native btRotationalLimitMotor2 m_enableMotor(boolean setter); - public native @Cast("btScalar") float m_targetVelocity(); public native btRotationalLimitMotor2 m_targetVelocity(float setter); - public native @Cast("btScalar") float m_maxMotorForce(); public native btRotationalLimitMotor2 m_maxMotorForce(float setter); - public native @Cast("bool") boolean m_servoMotor(); public native btRotationalLimitMotor2 m_servoMotor(boolean setter); - public native @Cast("btScalar") float m_servoTarget(); public native btRotationalLimitMotor2 m_servoTarget(float setter); - public native @Cast("bool") boolean m_enableSpring(); public native btRotationalLimitMotor2 m_enableSpring(boolean setter); - public native @Cast("btScalar") float m_springStiffness(); public native btRotationalLimitMotor2 m_springStiffness(float setter); - public native @Cast("bool") boolean m_springStiffnessLimited(); public native btRotationalLimitMotor2 m_springStiffnessLimited(boolean setter); - public native @Cast("btScalar") float m_springDamping(); public native btRotationalLimitMotor2 m_springDamping(float setter); - public native @Cast("bool") boolean m_springDampingLimited(); public native btRotationalLimitMotor2 m_springDampingLimited(boolean setter); - public native @Cast("btScalar") float m_equilibriumPoint(); public native btRotationalLimitMotor2 m_equilibriumPoint(float setter); - - public native @Cast("btScalar") float m_currentLimitError(); public native btRotationalLimitMotor2 m_currentLimitError(float setter); - public native @Cast("btScalar") float m_currentLimitErrorHi(); public native btRotationalLimitMotor2 m_currentLimitErrorHi(float setter); - public native @Cast("btScalar") float m_currentPosition(); public native btRotationalLimitMotor2 m_currentPosition(float setter); - public native int m_currentLimit(); public native btRotationalLimitMotor2 m_currentLimit(int setter); - - public btRotationalLimitMotor2() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btRotationalLimitMotor2(@Const @ByRef btRotationalLimitMotor2 limot) { super((Pointer)null); allocate(limot); } - private native void allocate(@Const @ByRef btRotationalLimitMotor2 limot); - - public native @Cast("bool") boolean isLimited(); - - public native void testLimitValue(@Cast("btScalar") float test_value); -} - -@NoOffset public static class btTranslationalLimitMotor2 extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTranslationalLimitMotor2(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTranslationalLimitMotor2(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btTranslationalLimitMotor2 position(long position) { - return (btTranslationalLimitMotor2)super.position(position); - } - @Override public btTranslationalLimitMotor2 getPointer(long i) { - return new btTranslationalLimitMotor2((Pointer)this).offsetAddress(i); - } - - // upper < lower means free - // upper == lower means locked - // upper > lower means limited - public native @ByRef btVector3 m_lowerLimit(); public native btTranslationalLimitMotor2 m_lowerLimit(btVector3 setter); - public native @ByRef btVector3 m_upperLimit(); public native btTranslationalLimitMotor2 m_upperLimit(btVector3 setter); - public native @ByRef btVector3 m_bounce(); public native btTranslationalLimitMotor2 m_bounce(btVector3 setter); - public native @ByRef btVector3 m_stopERP(); public native btTranslationalLimitMotor2 m_stopERP(btVector3 setter); - public native @ByRef btVector3 m_stopCFM(); public native btTranslationalLimitMotor2 m_stopCFM(btVector3 setter); - public native @ByRef btVector3 m_motorERP(); public native btTranslationalLimitMotor2 m_motorERP(btVector3 setter); - public native @ByRef btVector3 m_motorCFM(); public native btTranslationalLimitMotor2 m_motorCFM(btVector3 setter); - public native @Cast("bool") boolean m_enableMotor(int i); public native btTranslationalLimitMotor2 m_enableMotor(int i, boolean setter); - @MemberGetter public native @Cast("bool*") BoolPointer m_enableMotor(); - public native @Cast("bool") boolean m_servoMotor(int i); public native btTranslationalLimitMotor2 m_servoMotor(int i, boolean setter); - @MemberGetter public native @Cast("bool*") BoolPointer m_servoMotor(); - public native @Cast("bool") boolean m_enableSpring(int i); public native btTranslationalLimitMotor2 m_enableSpring(int i, boolean setter); - @MemberGetter public native @Cast("bool*") BoolPointer m_enableSpring(); - public native @ByRef btVector3 m_servoTarget(); public native btTranslationalLimitMotor2 m_servoTarget(btVector3 setter); - public native @ByRef btVector3 m_springStiffness(); public native btTranslationalLimitMotor2 m_springStiffness(btVector3 setter); - public native @Cast("bool") boolean m_springStiffnessLimited(int i); public native btTranslationalLimitMotor2 m_springStiffnessLimited(int i, boolean setter); - @MemberGetter public native @Cast("bool*") BoolPointer m_springStiffnessLimited(); - public native @ByRef btVector3 m_springDamping(); public native btTranslationalLimitMotor2 m_springDamping(btVector3 setter); - public native @Cast("bool") boolean m_springDampingLimited(int i); public native btTranslationalLimitMotor2 m_springDampingLimited(int i, boolean setter); - @MemberGetter public native @Cast("bool*") BoolPointer m_springDampingLimited(); - public native @ByRef btVector3 m_equilibriumPoint(); public native btTranslationalLimitMotor2 m_equilibriumPoint(btVector3 setter); - public native @ByRef btVector3 m_targetVelocity(); public native btTranslationalLimitMotor2 m_targetVelocity(btVector3 setter); - public native @ByRef btVector3 m_maxMotorForce(); public native btTranslationalLimitMotor2 m_maxMotorForce(btVector3 setter); - - public native @ByRef btVector3 m_currentLimitError(); public native btTranslationalLimitMotor2 m_currentLimitError(btVector3 setter); - public native @ByRef btVector3 m_currentLimitErrorHi(); public native btTranslationalLimitMotor2 m_currentLimitErrorHi(btVector3 setter); - public native @ByRef btVector3 m_currentLinearDiff(); public native btTranslationalLimitMotor2 m_currentLinearDiff(btVector3 setter); - public native int m_currentLimit(int i); public native btTranslationalLimitMotor2 m_currentLimit(int i, int setter); - @MemberGetter public native IntPointer m_currentLimit(); - - public btTranslationalLimitMotor2() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btTranslationalLimitMotor2(@Const @ByRef btTranslationalLimitMotor2 other) { super((Pointer)null); allocate(other); } - private native void allocate(@Const @ByRef btTranslationalLimitMotor2 other); - - public native @Cast("bool") boolean isLimited(int limitIndex); - - public native void testLimitValue(int limitIndex, @Cast("btScalar") float test_value); -} - -/** enum bt6DofFlags2 */ -public static final int - BT_6DOF_FLAGS_CFM_STOP2 = 1, - BT_6DOF_FLAGS_ERP_STOP2 = 2, - BT_6DOF_FLAGS_CFM_MOTO2 = 4, - BT_6DOF_FLAGS_ERP_MOTO2 = 8, - BT_6DOF_FLAGS_USE_INFINITE_ERROR = (1<<16); -public static final int BT_6DOF_FLAGS_AXIS_SHIFT2 = 4; // bits per axis - -@NoOffset public static class btGeneric6DofSpring2Constraint extends btTypedConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofSpring2Constraint(Pointer p) { super(p); } - - - public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, rotOrder); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/); - public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB); - public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/) { super((Pointer)null); allocate(rbB, frameInB, rotOrder); } - private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/); - public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbB, frameInB); } - private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB); - - public native void buildJacobian(); - public native int calculateSerializeBufferSize(); - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); - - public native btRotationalLimitMotor2 getRotationalLimitMotor(int index); - public native btTranslationalLimitMotor2 getTranslationalLimitMotor(); - - // Calculates the global transform for the joint offset for body A an B, and also calculates the angle differences between the bodies. - public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); - public native void calculateTransforms(); - - // Gets the global transform of the offset for body A - public native @Const @ByRef btTransform getCalculatedTransformA(); - // Gets the global transform of the offset for body B - public native @Const @ByRef btTransform getCalculatedTransformB(); - - public native @ByRef btTransform getFrameOffsetA(); - public native @ByRef btTransform getFrameOffsetB(); - - // Get the rotation axis in global coordinates ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) - public native @ByVal btVector3 getAxis(int axis_index); - - // Get the relative Euler angle ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) - public native @Cast("btScalar") float getAngle(int axis_index); - - // Get the relative position of the constraint pivot ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) - public native @Cast("btScalar") float getRelativePivotPosition(int axis_index); - - public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); - - public native void setLinearLowerLimit(@Const @ByRef btVector3 linearLower); - public native void getLinearLowerLimit(@ByRef btVector3 linearLower); - public native void setLinearUpperLimit(@Const @ByRef btVector3 linearUpper); - public native void getLinearUpperLimit(@ByRef btVector3 linearUpper); - - public native void setAngularLowerLimit(@Const @ByRef btVector3 angularLower); - - public native void setAngularLowerLimitReversed(@Const @ByRef btVector3 angularLower); - - public native void getAngularLowerLimit(@ByRef btVector3 angularLower); - - public native void getAngularLowerLimitReversed(@ByRef btVector3 angularLower); - - public native void setAngularUpperLimit(@Const @ByRef btVector3 angularUpper); - - public native void setAngularUpperLimitReversed(@Const @ByRef btVector3 angularUpper); - - public native void getAngularUpperLimit(@ByRef btVector3 angularUpper); - - public native void getAngularUpperLimitReversed(@ByRef btVector3 angularUpper); - - //first 3 are linear, next 3 are angular - - public native void setLimit(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); - - public native void setLimitReversed(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); - - public native @Cast("bool") boolean isLimited(int limitIndex); - - public native void setRotationOrder(@Cast("RotateOrder") int order); - public native @Cast("RotateOrder") int getRotationOrder(); - - public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); - - public native void setBounce(int index, @Cast("btScalar") float bounce); - - public native void enableMotor(int index, @Cast("bool") boolean onOff); - public native void setServo(int index, @Cast("bool") boolean onOff); // set the type of the motor (servo or not) (the motor has to be turned on for servo also) - public native void setTargetVelocity(int index, @Cast("btScalar") float velocity); - public native void setServoTarget(int index, @Cast("btScalar") float target); - public native void setMaxMotorForce(int index, @Cast("btScalar") float force); - - public native void enableSpring(int index, @Cast("bool") boolean onOff); - public native void setStiffness(int index, @Cast("btScalar") float stiffness, @Cast("bool") boolean limitIfNeeded/*=true*/); - public native void setStiffness(int index, @Cast("btScalar") float stiffness); // if limitIfNeeded is true the system will automatically limit the stiffness in necessary situations where otherwise the spring would move unrealistically too widely - public native void setDamping(int index, @Cast("btScalar") float damping, @Cast("bool") boolean limitIfNeeded/*=true*/); - public native void setDamping(int index, @Cast("btScalar") float damping); // if limitIfNeeded is true the system will automatically limit the damping in necessary situations where otherwise the spring would blow up - public native void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF - public native void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF - public native void setEquilibriumPoint(int index, @Cast("btScalar") float val); - - //override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). - //If no axis is provided, it uses the default axis for this constraint. - public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); - public native void setParam(int num, @Cast("btScalar") float value); - public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); - public native @Cast("btScalar") float getParam(int num); - - public static native @Cast("btScalar") float btGetMatrixElem(@Const @ByRef btMatrix3x3 mat, int index); - public static native @Cast("bool") boolean matrixToEulerXYZ(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); - public static native @Cast("bool") boolean matrixToEulerXZY(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); - public static native @Cast("bool") boolean matrixToEulerYXZ(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); - public static native @Cast("bool") boolean matrixToEulerYZX(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); - public static native @Cast("bool") boolean matrixToEulerZXY(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); - public static native @Cast("bool") boolean matrixToEulerZYX(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); -} - -public static class btGeneric6DofSpring2ConstraintData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btGeneric6DofSpring2ConstraintData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btGeneric6DofSpring2ConstraintData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofSpring2ConstraintData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btGeneric6DofSpring2ConstraintData position(long position) { - return (btGeneric6DofSpring2ConstraintData)super.position(position); - } - @Override public btGeneric6DofSpring2ConstraintData getPointer(long i) { - return new btGeneric6DofSpring2ConstraintData((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformFloatData m_rbAFrame(); public native btGeneric6DofSpring2ConstraintData m_rbAFrame(btTransformFloatData setter); - public native @ByRef btTransformFloatData m_rbBFrame(); public native btGeneric6DofSpring2ConstraintData m_rbBFrame(btTransformFloatData setter); - - public native @ByRef btVector3FloatData m_linearUpperLimit(); public native btGeneric6DofSpring2ConstraintData m_linearUpperLimit(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearLowerLimit(); public native btGeneric6DofSpring2ConstraintData m_linearLowerLimit(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearBounce(); public native btGeneric6DofSpring2ConstraintData m_linearBounce(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearStopERP(); public native btGeneric6DofSpring2ConstraintData m_linearStopERP(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearStopCFM(); public native btGeneric6DofSpring2ConstraintData m_linearStopCFM(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearMotorERP(); public native btGeneric6DofSpring2ConstraintData m_linearMotorERP(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearMotorCFM(); public native btGeneric6DofSpring2ConstraintData m_linearMotorCFM(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearTargetVelocity(); public native btGeneric6DofSpring2ConstraintData m_linearTargetVelocity(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearMaxMotorForce(); public native btGeneric6DofSpring2ConstraintData m_linearMaxMotorForce(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearServoTarget(); public native btGeneric6DofSpring2ConstraintData m_linearServoTarget(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearSpringStiffness(); public native btGeneric6DofSpring2ConstraintData m_linearSpringStiffness(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearSpringDamping(); public native btGeneric6DofSpring2ConstraintData m_linearSpringDamping(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_linearEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintData m_linearEquilibriumPoint(btVector3FloatData setter); - public native @Cast("char") byte m_linearEnableMotor(int i); public native btGeneric6DofSpring2ConstraintData m_linearEnableMotor(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearEnableMotor(); - public native @Cast("char") byte m_linearServoMotor(int i); public native btGeneric6DofSpring2ConstraintData m_linearServoMotor(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearServoMotor(); - public native @Cast("char") byte m_linearEnableSpring(int i); public native btGeneric6DofSpring2ConstraintData m_linearEnableSpring(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearEnableSpring(); - public native @Cast("char") byte m_linearSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintData m_linearSpringStiffnessLimited(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearSpringStiffnessLimited(); - public native @Cast("char") byte m_linearSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintData m_linearSpringDampingLimited(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearSpringDampingLimited(); - public native @Cast("char") byte m_padding1(int i); public native btGeneric6DofSpring2ConstraintData m_padding1(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding1(); - - public native @ByRef btVector3FloatData m_angularUpperLimit(); public native btGeneric6DofSpring2ConstraintData m_angularUpperLimit(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularLowerLimit(); public native btGeneric6DofSpring2ConstraintData m_angularLowerLimit(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularBounce(); public native btGeneric6DofSpring2ConstraintData m_angularBounce(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularStopERP(); public native btGeneric6DofSpring2ConstraintData m_angularStopERP(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularStopCFM(); public native btGeneric6DofSpring2ConstraintData m_angularStopCFM(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularMotorERP(); public native btGeneric6DofSpring2ConstraintData m_angularMotorERP(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularMotorCFM(); public native btGeneric6DofSpring2ConstraintData m_angularMotorCFM(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularTargetVelocity(); public native btGeneric6DofSpring2ConstraintData m_angularTargetVelocity(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularMaxMotorForce(); public native btGeneric6DofSpring2ConstraintData m_angularMaxMotorForce(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularServoTarget(); public native btGeneric6DofSpring2ConstraintData m_angularServoTarget(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularSpringStiffness(); public native btGeneric6DofSpring2ConstraintData m_angularSpringStiffness(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularSpringDamping(); public native btGeneric6DofSpring2ConstraintData m_angularSpringDamping(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_angularEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintData m_angularEquilibriumPoint(btVector3FloatData setter); - public native @Cast("char") byte m_angularEnableMotor(int i); public native btGeneric6DofSpring2ConstraintData m_angularEnableMotor(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularEnableMotor(); - public native @Cast("char") byte m_angularServoMotor(int i); public native btGeneric6DofSpring2ConstraintData m_angularServoMotor(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularServoMotor(); - public native @Cast("char") byte m_angularEnableSpring(int i); public native btGeneric6DofSpring2ConstraintData m_angularEnableSpring(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularEnableSpring(); - public native @Cast("char") byte m_angularSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintData m_angularSpringStiffnessLimited(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularSpringStiffnessLimited(); - public native @Cast("char") byte m_angularSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintData m_angularSpringDampingLimited(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularSpringDampingLimited(); - - public native int m_rotateOrder(); public native btGeneric6DofSpring2ConstraintData m_rotateOrder(int setter); -} - -public static class btGeneric6DofSpring2ConstraintDoubleData2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btGeneric6DofSpring2ConstraintDoubleData2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btGeneric6DofSpring2ConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGeneric6DofSpring2ConstraintDoubleData2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btGeneric6DofSpring2ConstraintDoubleData2 position(long position) { - return (btGeneric6DofSpring2ConstraintDoubleData2)super.position(position); - } - @Override public btGeneric6DofSpring2ConstraintDoubleData2 getPointer(long i) { - return new btGeneric6DofSpring2ConstraintDoubleData2((Pointer)this).offsetAddress(i); - } - - - public native @ByRef btTransformDoubleData m_rbAFrame(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); - public native @ByRef btTransformDoubleData m_rbBFrame(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); - - public native @ByRef btVector3DoubleData m_linearUpperLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearUpperLimit(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearLowerLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearLowerLimit(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearBounce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearBounce(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearStopERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearStopERP(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearStopCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearStopCFM(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearMotorERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMotorERP(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearMotorCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMotorCFM(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearTargetVelocity(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearTargetVelocity(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearMaxMotorForce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMaxMotorForce(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearServoTarget(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearServoTarget(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearSpringStiffness(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringStiffness(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearSpringDamping(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringDamping(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_linearEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEquilibriumPoint(btVector3DoubleData setter); - public native @Cast("char") byte m_linearEnableMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEnableMotor(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearEnableMotor(); - public native @Cast("char") byte m_linearServoMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearServoMotor(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearServoMotor(); - public native @Cast("char") byte m_linearEnableSpring(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEnableSpring(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearEnableSpring(); - public native @Cast("char") byte m_linearSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringStiffnessLimited(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearSpringStiffnessLimited(); - public native @Cast("char") byte m_linearSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringDampingLimited(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_linearSpringDampingLimited(); - public native @Cast("char") byte m_padding1(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_padding1(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding1(); - - public native @ByRef btVector3DoubleData m_angularUpperLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularUpperLimit(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularLowerLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularLowerLimit(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularBounce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularBounce(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularStopERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularStopERP(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularStopCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularStopCFM(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularMotorERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMotorERP(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularMotorCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMotorCFM(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularTargetVelocity(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularTargetVelocity(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularMaxMotorForce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMaxMotorForce(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularServoTarget(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularServoTarget(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularSpringStiffness(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringStiffness(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularSpringDamping(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringDamping(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_angularEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEquilibriumPoint(btVector3DoubleData setter); - public native @Cast("char") byte m_angularEnableMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEnableMotor(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularEnableMotor(); - public native @Cast("char") byte m_angularServoMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularServoMotor(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularServoMotor(); - public native @Cast("char") byte m_angularEnableSpring(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEnableSpring(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularEnableSpring(); - public native @Cast("char") byte m_angularSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringStiffnessLimited(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularSpringStiffnessLimited(); - public native @Cast("char") byte m_angularSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringDampingLimited(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_angularSpringDampingLimited(); - - public native int m_rotateOrder(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rotateOrder(int setter); -} - - - - - -// #endif //BT_GENERIC_6DOF_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btUniversalConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org -Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_UNIVERSAL_CONSTRAINT_H -// #define BT_UNIVERSAL_CONSTRAINT_H - -// #include "LinearMath/btVector3.h" -// #include "btTypedConstraint.h" -// #include "btGeneric6DofConstraint.h" - -/** Constraint similar to ODE Universal Joint - * has 2 rotatioonal degrees of freedom, similar to Euler rotations around Z (axis 1) - * and Y (axis 2) - * Description from ODE manual : - * "Given axis 1 on body 1, and axis 2 on body 2 that is perpendicular to axis 1, it keeps them perpendicular. - * In other words, rotation of the two bodies about the direction perpendicular to the two axes will be equal." */ - -@NoOffset public static class btUniversalConstraint extends btGeneric6DofConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btUniversalConstraint(Pointer p) { super(p); } - - - // constructor - // anchor, axis1 and axis2 are in world coordinate system - // axis1 must be orthogonal to axis2 - public btUniversalConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 anchor, @Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2) { super((Pointer)null); allocate(rbA, rbB, anchor, axis1, axis2); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 anchor, @Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); - // access - public native @Const @ByRef btVector3 getAnchor(); - public native @Const @ByRef btVector3 getAnchor2(); - public native @Const @ByRef btVector3 getAxis1(); - public native @Const @ByRef btVector3 getAxis2(); - public native @Cast("btScalar") float getAngle1(); - public native @Cast("btScalar") float getAngle2(); - // limits - public native void setUpperLimit(@Cast("btScalar") float ang1max, @Cast("btScalar") float ang2max); - public native void setLowerLimit(@Cast("btScalar") float ang1min, @Cast("btScalar") float ang2min); - - public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); -} - -// #endif // BT_UNIVERSAL_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btHinge2Constraint.h - -/* -Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org -Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_HINGE2_CONSTRAINT_H -// #define BT_HINGE2_CONSTRAINT_H - -// #include "LinearMath/btVector3.h" -// #include "btTypedConstraint.h" -// #include "btGeneric6DofSpring2Constraint.h" - -// Constraint similar to ODE Hinge2 Joint -// has 3 degrees of frredom: -// 2 rotational degrees of freedom, similar to Euler rotations around Z (axis 1) and X (axis 2) -// 1 translational (along axis Z) with suspension spring - -@NoOffset public static class btHinge2Constraint extends btGeneric6DofSpring2Constraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHinge2Constraint(Pointer p) { super(p); } - - - // constructor - // anchor, axis1 and axis2 are in world coordinate system - // axis1 must be orthogonal to axis2 - public btHinge2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @ByRef btVector3 anchor, @ByRef btVector3 axis1, @ByRef btVector3 axis2) { super((Pointer)null); allocate(rbA, rbB, anchor, axis1, axis2); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @ByRef btVector3 anchor, @ByRef btVector3 axis1, @ByRef btVector3 axis2); - // access - public native @Const @ByRef btVector3 getAnchor(); - public native @Const @ByRef btVector3 getAnchor2(); - public native @Const @ByRef btVector3 getAxis1(); - public native @Const @ByRef btVector3 getAxis2(); - public native @Cast("btScalar") float getAngle1(); - public native @Cast("btScalar") float getAngle2(); - // limits - public native void setUpperLimit(@Cast("btScalar") float ang1max); - public native void setLowerLimit(@Cast("btScalar") float ang1min); -} - -// #endif // BT_HINGE2_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btGearConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2012 Advanced Micro Devices, Inc. http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_GEAR_CONSTRAINT_H -// #define BT_GEAR_CONSTRAINT_H - -// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btGearConstraintData btGearConstraintFloatData -public static final String btGearConstraintDataName = "btGearConstraintFloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -/**The btGeatConstraint will couple the angular velocity for two bodies around given local axis and ratio. - * See Bullet/Demos/ConstraintDemo for an example use. */ -@NoOffset public static class btGearConstraint extends btTypedConstraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGearConstraint(Pointer p) { super(p); } - - public btGearConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("btScalar") float ratio/*=1.f*/) { super((Pointer)null); allocate(rbA, rbB, axisInA, axisInB, ratio); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("btScalar") float ratio/*=1.f*/); - public btGearConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, axisInA, axisInB); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); - - /**internal method used by the constraint solver, don't use them directly */ - - /**internal method used by the constraint solver, don't use them directly */ - - public native void setAxisA(@ByRef btVector3 axisA); - public native void setAxisB(@ByRef btVector3 axisB); - public native void setRatio(@Cast("btScalar") float ratio); - public native @Const @ByRef btVector3 getAxisA(); - public native @Const @ByRef btVector3 getAxisB(); - public native @Cast("btScalar") float getRatio(); - - public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); - public native void setParam(int num, @Cast("btScalar") float value); - - /**return the local value of parameter */ - public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); - public native @Cast("btScalar") float getParam(int num); - - public native int calculateSerializeBufferSize(); - - /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); -} - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ -public static class btGearConstraintFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btGearConstraintFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btGearConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGearConstraintFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btGearConstraintFloatData position(long position) { - return (btGearConstraintFloatData)super.position(position); - } - @Override public btGearConstraintFloatData getPointer(long i) { - return new btGearConstraintFloatData((Pointer)this).offsetAddress(i); - } - - - - public native @ByRef btVector3FloatData m_axisInA(); public native btGearConstraintFloatData m_axisInA(btVector3FloatData setter); - public native @ByRef btVector3FloatData m_axisInB(); public native btGearConstraintFloatData m_axisInB(btVector3FloatData setter); - - public native float m_ratio(); public native btGearConstraintFloatData m_ratio(float setter); - public native @Cast("char") byte m_padding(int i); public native btGearConstraintFloatData m_padding(int i, byte setter); - @MemberGetter public native @Cast("char*") BytePointer m_padding(); -} - -public static class btGearConstraintDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btGearConstraintDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btGearConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGearConstraintDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btGearConstraintDoubleData position(long position) { - return (btGearConstraintDoubleData)super.position(position); - } - @Override public btGearConstraintDoubleData getPointer(long i) { - return new btGearConstraintDoubleData((Pointer)this).offsetAddress(i); - } - - - - public native @ByRef btVector3DoubleData m_axisInA(); public native btGearConstraintDoubleData m_axisInA(btVector3DoubleData setter); - public native @ByRef btVector3DoubleData m_axisInB(); public native btGearConstraintDoubleData m_axisInB(btVector3DoubleData setter); - - public native double m_ratio(); public native btGearConstraintDoubleData m_ratio(double setter); -} - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ - - -// #endif //BT_GEAR_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btFixedConstraint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2013 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_FIXED_CONSTRAINT_H -// #define BT_FIXED_CONSTRAINT_H - -// #include "btGeneric6DofSpring2Constraint.h" - -public static class btFixedConstraint extends btGeneric6DofSpring2Constraint { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btFixedConstraint(Pointer p) { super(p); } - - public btFixedConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB); } - private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB); -} - -// #endif //BT_FIXED_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btConstraintSolver.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CONSTRAINT_SOLVER_H -// #define BT_CONSTRAINT_SOLVER_H - -// #include "LinearMath/btScalar.h" -@Opaque public static class btStackAlloc extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btStackAlloc() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btStackAlloc(Pointer p) { super(p); } -} -/** btConstraintSolver provides solver interface */ - -/** enum btConstraintSolverType */ -public static final int - BT_SEQUENTIAL_IMPULSE_SOLVER = 1, - BT_MLCP_SOLVER = 2, - BT_NNCG_SOLVER = 4, - BT_MULTIBODY_SOLVER = 8, - BT_BLOCK_SOLVER = 16; - -public static class btConstraintSolver extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btConstraintSolver(Pointer p) { super(p); } - - - public native void prepareSolve(int arg0, int arg1); - - /**solve a group of constraints */ - public native @Cast("btScalar") float solveGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); - public native @Cast("btScalar") float solveGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); - - public native void allSolved(@Const @ByRef btContactSolverInfo arg0, btIDebugDraw arg1); - - /**clear internal cached data and reset random seed */ - public native void reset(); - - public native @Cast("btConstraintSolverType") int getSolverType(); -} - -// #endif //BT_CONSTRAINT_SOLVER_H - - -// Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H -// #define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H -// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" -// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" -// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" -// #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" -// #include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" -// #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" - -@NoOffset public static class btSolverAnalyticsData extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSolverAnalyticsData(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btSolverAnalyticsData(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btSolverAnalyticsData position(long position) { - return (btSolverAnalyticsData)super.position(position); - } - @Override public btSolverAnalyticsData getPointer(long i) { - return new btSolverAnalyticsData((Pointer)this).offsetAddress(i); - } - - public btSolverAnalyticsData() { super((Pointer)null); allocate(); } - private native void allocate(); - public native int m_islandId(); public native btSolverAnalyticsData m_islandId(int setter); - public native int m_numBodies(); public native btSolverAnalyticsData m_numBodies(int setter); - public native int m_numContactManifolds(); public native btSolverAnalyticsData m_numContactManifolds(int setter); - public native int m_numSolverCalls(); public native btSolverAnalyticsData m_numSolverCalls(int setter); - public native int m_numIterationsUsed(); public native btSolverAnalyticsData m_numIterationsUsed(int setter); - public native double m_remainingLeastSquaresResidual(); public native btSolverAnalyticsData m_remainingLeastSquaresResidual(double setter); -} - -/**The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (iterative LCP) method. */ -@NoOffset public static class btSequentialImpulseConstraintSolver extends btConstraintSolver { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSequentialImpulseConstraintSolver(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btSequentialImpulseConstraintSolver(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btSequentialImpulseConstraintSolver position(long position) { - return (btSequentialImpulseConstraintSolver)super.position(position); - } - @Override public btSequentialImpulseConstraintSolver getPointer(long i) { - return new btSequentialImpulseConstraintSolver((Pointer)this).offsetAddress(i); - } - - - public btSequentialImpulseConstraintSolver() { super((Pointer)null); allocate(); } - private native void allocate(); - - public native @Cast("btScalar") float solveGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); - public native @Cast("btScalar") float solveGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); - - /**clear internal cached data and reset random seed */ - public native void reset(); - - public native @Cast("unsigned long") long btRand2(); - - public native int btRandInt2(int n); - - public native void setRandSeed(@Cast("unsigned long") long seed); - public native @Cast("unsigned long") long getRandSeed(); - - public native @Cast("btConstraintSolverType") int getSolverType(); - - - - /**Various implementations of solving a single constraint row using a generic equality constraint, using scalar reference, SSE2 or SSE4 */ - - /**Various implementations of solving a single constraint row using an inequality (lower limit) constraint, using scalar reference, SSE2 or SSE4 */ - public native @ByRef btSolverAnalyticsData m_analyticsData(); public native btSequentialImpulseConstraintSolver m_analyticsData(btSolverAnalyticsData setter); -} - -// #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H - - -// Parsed from BulletDynamics/Vehicle/btVehicleRaycaster.h - -/* - * Copyright (c) 2005 Erwin Coumans http://bulletphysics.org - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies. - * Erwin Coumans makes no representations about the suitability - * of this software for any purpose. - * It is provided "as is" without express or implied warranty. -*/ -// #ifndef BT_VEHICLE_RAYCASTER_H -// #define BT_VEHICLE_RAYCASTER_H - -// #include "LinearMath/btVector3.h" - -/** btVehicleRaycaster is provides interface for between vehicle simulation and raycasting */ -public static class btVehicleRaycaster extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVehicleRaycaster(Pointer p) { super(p); } - - @NoOffset public static class btVehicleRaycasterResult extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVehicleRaycasterResult(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btVehicleRaycasterResult(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btVehicleRaycasterResult position(long position) { - return (btVehicleRaycasterResult)super.position(position); - } - @Override public btVehicleRaycasterResult getPointer(long i) { - return new btVehicleRaycasterResult((Pointer)this).offsetAddress(i); - } - - public btVehicleRaycasterResult() { super((Pointer)null); allocate(); } - private native void allocate(); - public native @ByRef btVector3 m_hitPointInWorld(); public native btVehicleRaycasterResult m_hitPointInWorld(btVector3 setter); - public native @ByRef btVector3 m_hitNormalInWorld(); public native btVehicleRaycasterResult m_hitNormalInWorld(btVector3 setter); - public native @Cast("btScalar") float m_distFraction(); public native btVehicleRaycasterResult m_distFraction(float setter); - } - - public native Pointer castRay(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @ByRef btVehicleRaycasterResult result); -} - -// #endif //BT_VEHICLE_RAYCASTER_H - - -// Parsed from BulletDynamics/Vehicle/btWheelInfo.h - -/* - * Copyright (c) 2005 Erwin Coumans https://bulletphysics.org - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies. - * Erwin Coumans makes no representations about the suitability - * of this software for any purpose. - * It is provided "as is" without express or implied warranty. -*/ -// #ifndef BT_WHEEL_INFO_H -// #define BT_WHEEL_INFO_H - -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" - -public static class btWheelInfoConstructionInfo extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btWheelInfoConstructionInfo() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btWheelInfoConstructionInfo(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btWheelInfoConstructionInfo(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btWheelInfoConstructionInfo position(long position) { - return (btWheelInfoConstructionInfo)super.position(position); - } - @Override public btWheelInfoConstructionInfo getPointer(long i) { - return new btWheelInfoConstructionInfo((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3 m_chassisConnectionCS(); public native btWheelInfoConstructionInfo m_chassisConnectionCS(btVector3 setter); - public native @ByRef btVector3 m_wheelDirectionCS(); public native btWheelInfoConstructionInfo m_wheelDirectionCS(btVector3 setter); - public native @ByRef btVector3 m_wheelAxleCS(); public native btWheelInfoConstructionInfo m_wheelAxleCS(btVector3 setter); - public native @Cast("btScalar") float m_suspensionRestLength(); public native btWheelInfoConstructionInfo m_suspensionRestLength(float setter); - public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btWheelInfoConstructionInfo m_maxSuspensionTravelCm(float setter); - public native @Cast("btScalar") float m_wheelRadius(); public native btWheelInfoConstructionInfo m_wheelRadius(float setter); - - public native @Cast("btScalar") float m_suspensionStiffness(); public native btWheelInfoConstructionInfo m_suspensionStiffness(float setter); - public native @Cast("btScalar") float m_wheelsDampingCompression(); public native btWheelInfoConstructionInfo m_wheelsDampingCompression(float setter); - public native @Cast("btScalar") float m_wheelsDampingRelaxation(); public native btWheelInfoConstructionInfo m_wheelsDampingRelaxation(float setter); - public native @Cast("btScalar") float m_frictionSlip(); public native btWheelInfoConstructionInfo m_frictionSlip(float setter); - public native @Cast("btScalar") float m_maxSuspensionForce(); public native btWheelInfoConstructionInfo m_maxSuspensionForce(float setter); - public native @Cast("bool") boolean m_bIsFrontWheel(); public native btWheelInfoConstructionInfo m_bIsFrontWheel(boolean setter); -} - -/** btWheelInfo contains information per wheel about friction and suspension. */ -@NoOffset public static class btWheelInfo extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btWheelInfo(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btWheelInfo(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btWheelInfo position(long position) { - return (btWheelInfo)super.position(position); - } - @Override public btWheelInfo getPointer(long i) { - return new btWheelInfo((Pointer)this).offsetAddress(i); - } - - public static class RaycastInfo extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public RaycastInfo() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public RaycastInfo(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public RaycastInfo(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public RaycastInfo position(long position) { - return (RaycastInfo)super.position(position); - } - @Override public RaycastInfo getPointer(long i) { - return new RaycastInfo((Pointer)this).offsetAddress(i); - } - - //set by raycaster - public native @ByRef btVector3 m_contactNormalWS(); public native RaycastInfo m_contactNormalWS(btVector3 setter); //contactnormal - public native @ByRef btVector3 m_contactPointWS(); public native RaycastInfo m_contactPointWS(btVector3 setter); //raycast hitpoint - public native @Cast("btScalar") float m_suspensionLength(); public native RaycastInfo m_suspensionLength(float setter); - public native @ByRef btVector3 m_hardPointWS(); public native RaycastInfo m_hardPointWS(btVector3 setter); //raycast starting point - public native @ByRef btVector3 m_wheelDirectionWS(); public native RaycastInfo m_wheelDirectionWS(btVector3 setter); //direction in worldspace - public native @ByRef btVector3 m_wheelAxleWS(); public native RaycastInfo m_wheelAxleWS(btVector3 setter); // axle in worldspace - public native @Cast("bool") boolean m_isInContact(); public native RaycastInfo m_isInContact(boolean setter); - public native Pointer m_groundObject(); public native RaycastInfo m_groundObject(Pointer setter); //could be general void* ptr - } - - public native @ByRef RaycastInfo m_raycastInfo(); public native btWheelInfo m_raycastInfo(RaycastInfo setter); - - public native @ByRef btTransform m_worldTransform(); public native btWheelInfo m_worldTransform(btTransform setter); - - public native @ByRef btVector3 m_chassisConnectionPointCS(); public native btWheelInfo m_chassisConnectionPointCS(btVector3 setter); //const - public native @ByRef btVector3 m_wheelDirectionCS(); public native btWheelInfo m_wheelDirectionCS(btVector3 setter); //const - public native @ByRef btVector3 m_wheelAxleCS(); public native btWheelInfo m_wheelAxleCS(btVector3 setter); // const or modified by steering - public native @Cast("btScalar") float m_suspensionRestLength1(); public native btWheelInfo m_suspensionRestLength1(float setter); //const - public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btWheelInfo m_maxSuspensionTravelCm(float setter); - public native @Cast("btScalar") float getSuspensionRestLength(); - public native @Cast("btScalar") float m_wheelsRadius(); public native btWheelInfo m_wheelsRadius(float setter); //const - public native @Cast("btScalar") float m_suspensionStiffness(); public native btWheelInfo m_suspensionStiffness(float setter); //const - public native @Cast("btScalar") float m_wheelsDampingCompression(); public native btWheelInfo m_wheelsDampingCompression(float setter); //const - public native @Cast("btScalar") float m_wheelsDampingRelaxation(); public native btWheelInfo m_wheelsDampingRelaxation(float setter); //const - public native @Cast("btScalar") float m_frictionSlip(); public native btWheelInfo m_frictionSlip(float setter); - public native @Cast("btScalar") float m_steering(); public native btWheelInfo m_steering(float setter); - public native @Cast("btScalar") float m_rotation(); public native btWheelInfo m_rotation(float setter); - public native @Cast("btScalar") float m_deltaRotation(); public native btWheelInfo m_deltaRotation(float setter); - public native @Cast("btScalar") float m_rollInfluence(); public native btWheelInfo m_rollInfluence(float setter); - public native @Cast("btScalar") float m_maxSuspensionForce(); public native btWheelInfo m_maxSuspensionForce(float setter); - - public native @Cast("btScalar") float m_engineForce(); public native btWheelInfo m_engineForce(float setter); - - public native @Cast("btScalar") float m_brake(); public native btWheelInfo m_brake(float setter); - - public native @Cast("bool") boolean m_bIsFrontWheel(); public native btWheelInfo m_bIsFrontWheel(boolean setter); - - public native Pointer m_clientInfo(); public native btWheelInfo m_clientInfo(Pointer setter); //can be used to store pointer to sync transforms... - - public btWheelInfo() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btWheelInfo(@ByRef btWheelInfoConstructionInfo ci) { super((Pointer)null); allocate(ci); } - private native void allocate(@ByRef btWheelInfoConstructionInfo ci); - - public native void updateWheel(@Const @ByRef btRigidBody chassis, @ByRef RaycastInfo raycastInfo); - - public native @Cast("btScalar") float m_clippedInvContactDotSuspension(); public native btWheelInfo m_clippedInvContactDotSuspension(float setter); - public native @Cast("btScalar") float m_suspensionRelativeVelocity(); public native btWheelInfo m_suspensionRelativeVelocity(float setter); - //calculated by suspension - public native @Cast("btScalar") float m_wheelsSuspensionForce(); public native btWheelInfo m_wheelsSuspensionForce(float setter); - public native @Cast("btScalar") float m_skidInfo(); public native btWheelInfo m_skidInfo(float setter); -} - -// #endif //BT_WHEEL_INFO_H - - -// Parsed from BulletDynamics/Vehicle/btRaycastVehicle.h - -/* - * Copyright (c) 2005 Erwin Coumans https://bulletphysics.org - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies. - * Erwin Coumans makes no representations about the suitability - * of this software for any purpose. - * It is provided "as is" without express or implied warranty. -*/ -// #ifndef BT_RAYCASTVEHICLE_H -// #define BT_RAYCASTVEHICLE_H - -// #include "BulletDynamics/Dynamics/btRigidBody.h" -// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" -// #include "btVehicleRaycaster.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #include "btWheelInfo.h" -// #include "BulletDynamics/Dynamics/btActionInterface.h" - -//class btVehicleTuning; - -/**rayCast vehicle, very special constraint that turn a rigidbody into a vehicle. */ -@NoOffset public static class btRaycastVehicle extends btActionInterface { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRaycastVehicle(Pointer p) { super(p); } - - @NoOffset public static class btVehicleTuning extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVehicleTuning(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btVehicleTuning(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btVehicleTuning position(long position) { - return (btVehicleTuning)super.position(position); - } - @Override public btVehicleTuning getPointer(long i) { - return new btVehicleTuning((Pointer)this).offsetAddress(i); - } - - public btVehicleTuning() { super((Pointer)null); allocate(); } - private native void allocate(); - public native @Cast("btScalar") float m_suspensionStiffness(); public native btVehicleTuning m_suspensionStiffness(float setter); - public native @Cast("btScalar") float m_suspensionCompression(); public native btVehicleTuning m_suspensionCompression(float setter); - public native @Cast("btScalar") float m_suspensionDamping(); public native btVehicleTuning m_suspensionDamping(float setter); - public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btVehicleTuning m_maxSuspensionTravelCm(float setter); - public native @Cast("btScalar") float m_frictionSlip(); public native btVehicleTuning m_frictionSlip(float setter); - public native @Cast("btScalar") float m_maxSuspensionForce(); public native btVehicleTuning m_maxSuspensionForce(float setter); - } - //constructor to create a car from an existing rigidbody - public btRaycastVehicle(@Const @ByRef btVehicleTuning tuning, btRigidBody chassis, btVehicleRaycaster raycaster) { super((Pointer)null); allocate(tuning, chassis, raycaster); } - private native void allocate(@Const @ByRef btVehicleTuning tuning, btRigidBody chassis, btVehicleRaycaster raycaster); - - /**btActionInterface interface */ - public native void updateAction(btCollisionWorld collisionWorld, @Cast("btScalar") float step); - - /**btActionInterface interface */ - public native void debugDraw(btIDebugDraw debugDrawer); - - public native @Const @ByRef btTransform getChassisWorldTransform(); - - public native @Cast("btScalar") float rayCast(@ByRef btWheelInfo wheel); - - public native void updateVehicle(@Cast("btScalar") float step); - - public native void resetSuspension(); - - public native @Cast("btScalar") float getSteeringValue(int wheel); - - public native void setSteeringValue(@Cast("btScalar") float steering, int wheel); - - public native void applyEngineForce(@Cast("btScalar") float force, int wheel); - - public native @Const @ByRef btTransform getWheelTransformWS(int wheelIndex); - - public native void updateWheelTransform(int wheelIndex, @Cast("bool") boolean interpolatedTransform/*=true*/); - public native void updateWheelTransform(int wheelIndex); - - // void setRaycastWheelInfo( int wheelIndex , bool isInContact, const btVector3& hitPoint, const btVector3& hitNormal,btScalar depth); - - public native @ByRef btWheelInfo addWheel(@Const @ByRef btVector3 connectionPointCS0, @Const @ByRef btVector3 wheelDirectionCS0, @Const @ByRef btVector3 wheelAxleCS, @Cast("btScalar") float suspensionRestLength, @Cast("btScalar") float wheelRadius, @Const @ByRef btVehicleTuning tuning, @Cast("bool") boolean isFrontWheel); - - public native int getNumWheels(); - - - - public native @ByRef btWheelInfo getWheelInfo(int index); - - public native void updateWheelTransformsWS(@ByRef btWheelInfo wheel, @Cast("bool") boolean interpolatedTransform/*=true*/); - public native void updateWheelTransformsWS(@ByRef btWheelInfo wheel); - - public native void setBrake(@Cast("btScalar") float brake, int wheelIndex); - - public native void setPitchControl(@Cast("btScalar") float pitch); - - public native void updateSuspension(@Cast("btScalar") float deltaTime); - - public native void updateFriction(@Cast("btScalar") float timeStep); - - public native btRigidBody getRigidBody(); - - public native int getRightAxis(); - public native int getUpAxis(); - - public native int getForwardAxis(); - - /**Worldspace forward vector */ - public native @ByVal btVector3 getForwardVector(); - - /**Velocity of vehicle (positive if velocity vector has same direction as foward vector) */ - public native @Cast("btScalar") float getCurrentSpeedKmHour(); - - public native void setCoordinateSystem(int rightIndex, int upIndex, int forwardIndex); - - /**backwards compatibility */ - public native int getUserConstraintType(); - - public native void setUserConstraintType(int userConstraintType); - - public native void setUserConstraintId(int uid); - - public native int getUserConstraintId(); -} - -@NoOffset public static class btDefaultVehicleRaycaster extends btVehicleRaycaster { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDefaultVehicleRaycaster(Pointer p) { super(p); } - - public btDefaultVehicleRaycaster(btDynamicsWorld world) { super((Pointer)null); allocate(world); } - private native void allocate(btDynamicsWorld world); - - public native Pointer castRay(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @ByRef btVehicleRaycasterResult result); -} - -// #endif //BT_RAYCASTVEHICLE_H - - -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java new file mode 100644 index 00000000000..8b1cff8d363 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class InplaceSolverIslandCallback extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public InplaceSolverIslandCallback() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public InplaceSolverIslandCallback(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java new file mode 100644 index 00000000000..f8bfc1644bf --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btActionInterface extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btActionInterface() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btActionInterface(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java new file mode 100644 index 00000000000..07f62908439 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java @@ -0,0 +1,94 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btAlignedObjectArray_btRigidBodyPointer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btRigidBodyPointer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btRigidBodyPointer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btRigidBodyPointer position(long position) { + return (btAlignedObjectArray_btRigidBodyPointer)super.position(position); + } + @Override public btAlignedObjectArray_btRigidBodyPointer getPointer(long i) { + return new btAlignedObjectArray_btRigidBodyPointer((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btRigidBodyPointer put(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer other); + public btAlignedObjectArray_btRigidBodyPointer() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btRigidBodyPointer(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btRigidBody at(int n); + + public native @ByPtrRef @Name("operator []") btRigidBody get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btRigidBody fillData/*=btRigidBody*()*/); + public native void resize(int newsize); + public native @ByPtrRef btRigidBody expandNonInitializing(); + + public native @ByPtrRef btRigidBody expand(@ByPtrRef btRigidBody fillValue/*=btRigidBody*()*/); + public native @ByPtrRef btRigidBody expand(); + + public native void push_back(@ByPtrRef btRigidBody _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btRigidBody key); + + public native int findLinearSearch(@ByPtrRef btRigidBody key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btRigidBody key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btRigidBody key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java new file mode 100644 index 00000000000..d5b42e0e6c6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java @@ -0,0 +1,130 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc) */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btConeTwistConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeTwistConstraint(Pointer p) { super(p); } + + + public btConeTwistConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); + + public btConeTwistConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); + + public native void buildJacobian(); + + + + public native void updateRHS(@Cast("btScalar") float timeStep); + + public native @Const @ByRef btRigidBody getRigidBodyA(); + public native @Const @ByRef btRigidBody getRigidBodyB(); + + public native void setAngularOnly(@Cast("bool") boolean angularOnly); + + public native @Cast("bool") boolean getAngularOnly(); + + public native void setLimit(int limitIndex, @Cast("btScalar") float limitValue); + + public native @Cast("btScalar") float getLimit(int limitIndex); + + // setLimit(), a few notes: + // _softness: + // 0->1, recommend ~0.8->1. + // describes % of limits where movement is free. + // beyond this softness %, the limit is gradually enforced until the "hard" (1.0) limit is reached. + // _biasFactor: + // 0->1?, recommend 0.3 +/-0.3 or so. + // strength with which constraint resists zeroth order (angular, not angular velocity) limit violation. + // __relaxationFactor: + // 0->1, recommend to stay near 1. + // the lower the value, the less the constraint will fight velocities which violate the angular limits. + public native void setLimit(@Cast("btScalar") float _swingSpan1, @Cast("btScalar") float _swingSpan2, @Cast("btScalar") float _twistSpan, @Cast("btScalar") float _softness/*=1.f*/, @Cast("btScalar") float _biasFactor/*=0.3f*/, @Cast("btScalar") float _relaxationFactor/*=1.0f*/); + public native void setLimit(@Cast("btScalar") float _swingSpan1, @Cast("btScalar") float _swingSpan2, @Cast("btScalar") float _twistSpan); + + public native @Const @ByRef btTransform getAFrame(); + public native @Const @ByRef btTransform getBFrame(); + + public native int getSolveTwistLimit(); + + public native int getSolveSwingLimit(); + + public native @Cast("btScalar") float getTwistLimitSign(); + + public native void calcAngleInfo(); + public native void calcAngleInfo2(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btMatrix3x3 invInertiaWorldA, @Const @ByRef btMatrix3x3 invInertiaWorldB); + + public native @Cast("btScalar") float getSwingSpan1(); + public native @Cast("btScalar") float getSwingSpan2(); + public native @Cast("btScalar") float getTwistSpan(); + public native @Cast("btScalar") float getLimitSoftness(); + public native @Cast("btScalar") float getBiasFactor(); + public native @Cast("btScalar") float getRelaxationFactor(); + public native @Cast("btScalar") float getTwistAngle(); + public native @Cast("bool") boolean isPastSwingLimit(); + + public native @Cast("btScalar") float getDamping(); + public native void setDamping(@Cast("btScalar") float damping); + + public native void enableMotor(@Cast("bool") boolean b); + public native @Cast("bool") boolean isMotorEnabled(); + public native @Cast("btScalar") float getMaxMotorImpulse(); + public native @Cast("bool") boolean isMaxMotorImpulseNormalized(); + public native void setMaxMotorImpulse(@Cast("btScalar") float maxMotorImpulse); + public native void setMaxMotorImpulseNormalized(@Cast("btScalar") float maxMotorImpulse); + + public native @Cast("btScalar") float getFixThresh(); + public native void setFixThresh(@Cast("btScalar") float fixThresh); + + // setMotorTarget: + // q: the desired rotation of bodyA wrt bodyB. + // note: if q violates the joint limits, the internal target is clamped to avoid conflicting impulses (very bad for stability) + // note: don't forget to enableMotor() + public native void setMotorTarget(@Const @ByRef btQuaternion q); + public native @Const @ByRef btQuaternion getMotorTarget(); + + // same as above, but q is the desired rotation of frameA wrt frameB in constraint space + public native void setMotorTargetInConstraintSpace(@Const @ByRef btQuaternion q); + + public native @ByVal btVector3 GetPointForAngle(@Cast("btScalar") float fAngleInRadians, @Cast("btScalar") float fLength); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + public native @Const @ByRef btTransform getFrameOffsetA(); + + public native @Const @ByRef btTransform getFrameOffsetB(); + + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java new file mode 100644 index 00000000000..95933f89e0d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +/**this structure is not used, except for loading pre-2.82 .bullet files */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btConeTwistConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConeTwistConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConeTwistConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeTwistConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConeTwistConstraintData position(long position) { + return (btConeTwistConstraintData)super.position(position); + } + @Override public btConeTwistConstraintData getPointer(long i) { + return new btConeTwistConstraintData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btConeTwistConstraintData m_rbAFrame(btTransformFloatData setter); + public native @ByRef btTransformFloatData m_rbBFrame(); public native btConeTwistConstraintData m_rbBFrame(btTransformFloatData setter); + + //limits + public native float m_swingSpan1(); public native btConeTwistConstraintData m_swingSpan1(float setter); + public native float m_swingSpan2(); public native btConeTwistConstraintData m_swingSpan2(float setter); + public native float m_twistSpan(); public native btConeTwistConstraintData m_twistSpan(float setter); + public native float m_limitSoftness(); public native btConeTwistConstraintData m_limitSoftness(float setter); + public native float m_biasFactor(); public native btConeTwistConstraintData m_biasFactor(float setter); + public native float m_relaxationFactor(); public native btConeTwistConstraintData m_relaxationFactor(float setter); + + public native float m_damping(); public native btConeTwistConstraintData m_damping(float setter); + + public native @Cast("char") byte m_pad(int i); public native btConeTwistConstraintData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java new file mode 100644 index 00000000000..81d2742cff5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btConeTwistConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConeTwistConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConeTwistConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeTwistConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConeTwistConstraintDoubleData position(long position) { + return (btConeTwistConstraintDoubleData)super.position(position); + } + @Override public btConeTwistConstraintDoubleData getPointer(long i) { + return new btConeTwistConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btConeTwistConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btConeTwistConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); + + //limits + public native double m_swingSpan1(); public native btConeTwistConstraintDoubleData m_swingSpan1(double setter); + public native double m_swingSpan2(); public native btConeTwistConstraintDoubleData m_swingSpan2(double setter); + public native double m_twistSpan(); public native btConeTwistConstraintDoubleData m_twistSpan(double setter); + public native double m_limitSoftness(); public native btConeTwistConstraintDoubleData m_limitSoftness(double setter); + public native double m_biasFactor(); public native btConeTwistConstraintDoubleData m_biasFactor(double setter); + public native double m_relaxationFactor(); public native btConeTwistConstraintDoubleData m_relaxationFactor(double setter); + + public native double m_damping(); public native btConeTwistConstraintDoubleData m_damping(double setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java new file mode 100644 index 00000000000..211e0776b16 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif //BT_USE_DOUBLE_PRECISION + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btConstraintSetting extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintSetting(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConstraintSetting(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btConstraintSetting position(long position) { + return (btConstraintSetting)super.position(position); + } + @Override public btConstraintSetting getPointer(long i) { + return new btConstraintSetting((Pointer)this).offsetAddress(i); + } + + public btConstraintSetting() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float m_tau(); public native btConstraintSetting m_tau(float setter); + public native @Cast("btScalar") float m_damping(); public native btConstraintSetting m_damping(float setter); + public native @Cast("btScalar") float m_impulseClamp(); public native btConstraintSetting m_impulseClamp(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java new file mode 100644 index 00000000000..e0bebb9bf22 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btConstraintSolver extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintSolver(Pointer p) { super(p); } + + + public native void prepareSolve(int arg0, int arg1); + + /**solve a group of constraints */ + public native @Cast("btScalar") float solveGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + public native @Cast("btScalar") float solveGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + + public native void allSolved(@Const @ByRef btContactSolverInfo arg0, btIDebugDraw arg1); + + /**clear internal cached data and reset random seed */ + public native void reset(); + + public native @Cast("btConstraintSolverType") int getSolverType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java new file mode 100644 index 00000000000..7c85bea05f5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btContactSolverInfo extends btContactSolverInfoData { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactSolverInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactSolverInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btContactSolverInfo position(long position) { + return (btContactSolverInfo)super.position(position); + } + @Override public btContactSolverInfo getPointer(long i) { + return new btContactSolverInfo((Pointer)this).offsetAddress(i); + } + + public btContactSolverInfo() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java new file mode 100644 index 00000000000..75d6105310f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java @@ -0,0 +1,70 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btContactSolverInfoData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btContactSolverInfoData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactSolverInfoData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactSolverInfoData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btContactSolverInfoData position(long position) { + return (btContactSolverInfoData)super.position(position); + } + @Override public btContactSolverInfoData getPointer(long i) { + return new btContactSolverInfoData((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_tau(); public native btContactSolverInfoData m_tau(float setter); + public native @Cast("btScalar") float m_damping(); public native btContactSolverInfoData m_damping(float setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native @Cast("btScalar") float m_friction(); public native btContactSolverInfoData m_friction(float setter); + public native @Cast("btScalar") float m_timeStep(); public native btContactSolverInfoData m_timeStep(float setter); + public native @Cast("btScalar") float m_restitution(); public native btContactSolverInfoData m_restitution(float setter); + public native int m_numIterations(); public native btContactSolverInfoData m_numIterations(int setter); + public native @Cast("btScalar") float m_maxErrorReduction(); public native btContactSolverInfoData m_maxErrorReduction(float setter); + public native @Cast("btScalar") float m_sor(); public native btContactSolverInfoData m_sor(float setter); //successive over-relaxation term + public native @Cast("btScalar") float m_erp(); public native btContactSolverInfoData m_erp(float setter); //error reduction for non-contact constraints + public native @Cast("btScalar") float m_erp2(); public native btContactSolverInfoData m_erp2(float setter); //error reduction for contact constraints + public native @Cast("btScalar") float m_deformable_erp(); public native btContactSolverInfoData m_deformable_erp(float setter); //error reduction for deformable constraints + public native @Cast("btScalar") float m_deformable_cfm(); public native btContactSolverInfoData m_deformable_cfm(float setter); //constraint force mixing for deformable constraints + public native @Cast("btScalar") float m_deformable_maxErrorReduction(); public native btContactSolverInfoData m_deformable_maxErrorReduction(float setter); // maxErrorReduction for deformable contact + public native @Cast("btScalar") float m_globalCfm(); public native btContactSolverInfoData m_globalCfm(float setter); //constraint force mixing for contacts and non-contacts + public native @Cast("btScalar") float m_frictionERP(); public native btContactSolverInfoData m_frictionERP(float setter); //error reduction for friction constraints + public native @Cast("btScalar") float m_frictionCFM(); public native btContactSolverInfoData m_frictionCFM(float setter); //constraint force mixing for friction constraints + + public native int m_splitImpulse(); public native btContactSolverInfoData m_splitImpulse(int setter); + public native @Cast("btScalar") float m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoData m_splitImpulsePenetrationThreshold(float setter); + public native @Cast("btScalar") float m_splitImpulseTurnErp(); public native btContactSolverInfoData m_splitImpulseTurnErp(float setter); + public native @Cast("btScalar") float m_linearSlop(); public native btContactSolverInfoData m_linearSlop(float setter); + public native @Cast("btScalar") float m_warmstartingFactor(); public native btContactSolverInfoData m_warmstartingFactor(float setter); + public native @Cast("btScalar") float m_articulatedWarmstartingFactor(); public native btContactSolverInfoData m_articulatedWarmstartingFactor(float setter); + public native int m_solverMode(); public native btContactSolverInfoData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoData m_restingContactRestitutionThreshold(int setter); + public native int m_minimumSolverBatchSize(); public native btContactSolverInfoData m_minimumSolverBatchSize(int setter); + public native @Cast("btScalar") float m_maxGyroscopicForce(); public native btContactSolverInfoData m_maxGyroscopicForce(float setter); + public native @Cast("btScalar") float m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoData m_singleAxisRollingFrictionThreshold(float setter); + public native @Cast("btScalar") float m_leastSquaresResidualThreshold(); public native btContactSolverInfoData m_leastSquaresResidualThreshold(float setter); + public native @Cast("btScalar") float m_restitutionVelocityThreshold(); public native btContactSolverInfoData m_restitutionVelocityThreshold(float setter); + public native @Cast("bool") boolean m_jointFeedbackInWorldSpace(); public native btContactSolverInfoData m_jointFeedbackInWorldSpace(boolean setter); + public native @Cast("bool") boolean m_jointFeedbackInJointFrame(); public native btContactSolverInfoData m_jointFeedbackInJointFrame(boolean setter); + public native int m_reportSolverAnalytics(); public native btContactSolverInfoData m_reportSolverAnalytics(int setter); + public native int m_numNonContactInnerIterations(); public native btContactSolverInfoData m_numNonContactInnerIterations(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoDoubleData.java new file mode 100644 index 00000000000..fae0e795640 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoDoubleData.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btContactSolverInfoDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btContactSolverInfoDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactSolverInfoDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactSolverInfoDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btContactSolverInfoDoubleData position(long position) { + return (btContactSolverInfoDoubleData)super.position(position); + } + @Override public btContactSolverInfoDoubleData getPointer(long i) { + return new btContactSolverInfoDoubleData((Pointer)this).offsetAddress(i); + } + + public native double m_tau(); public native btContactSolverInfoDoubleData m_tau(double setter); + public native double m_damping(); public native btContactSolverInfoDoubleData m_damping(double setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native double m_friction(); public native btContactSolverInfoDoubleData m_friction(double setter); + public native double m_timeStep(); public native btContactSolverInfoDoubleData m_timeStep(double setter); + public native double m_restitution(); public native btContactSolverInfoDoubleData m_restitution(double setter); + public native double m_maxErrorReduction(); public native btContactSolverInfoDoubleData m_maxErrorReduction(double setter); + public native double m_sor(); public native btContactSolverInfoDoubleData m_sor(double setter); + public native double m_erp(); public native btContactSolverInfoDoubleData m_erp(double setter); //used as Baumgarte factor + public native double m_erp2(); public native btContactSolverInfoDoubleData m_erp2(double setter); //used in Split Impulse + public native double m_globalCfm(); public native btContactSolverInfoDoubleData m_globalCfm(double setter); //constraint force mixing + public native double m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoDoubleData m_splitImpulsePenetrationThreshold(double setter); + public native double m_splitImpulseTurnErp(); public native btContactSolverInfoDoubleData m_splitImpulseTurnErp(double setter); + public native double m_linearSlop(); public native btContactSolverInfoDoubleData m_linearSlop(double setter); + public native double m_warmstartingFactor(); public native btContactSolverInfoDoubleData m_warmstartingFactor(double setter); + public native double m_articulatedWarmstartingFactor(); public native btContactSolverInfoDoubleData m_articulatedWarmstartingFactor(double setter); + public native double m_maxGyroscopicForce(); public native btContactSolverInfoDoubleData m_maxGyroscopicForce(double setter); /**it is only used for 'explicit' version of gyroscopic force */ + public native double m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoDoubleData m_singleAxisRollingFrictionThreshold(double setter); + + public native int m_numIterations(); public native btContactSolverInfoDoubleData m_numIterations(int setter); + public native int m_solverMode(); public native btContactSolverInfoDoubleData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoDoubleData m_restingContactRestitutionThreshold(int setter); + public native int m_minimumSolverBatchSize(); public native btContactSolverInfoDoubleData m_minimumSolverBatchSize(int setter); + public native int m_splitImpulse(); public native btContactSolverInfoDoubleData m_splitImpulse(int setter); + public native @Cast("char") byte m_padding(int i); public native btContactSolverInfoDoubleData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoFloatData.java new file mode 100644 index 00000000000..45bed51079e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoFloatData.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btContactSolverInfoFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btContactSolverInfoFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactSolverInfoFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactSolverInfoFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btContactSolverInfoFloatData position(long position) { + return (btContactSolverInfoFloatData)super.position(position); + } + @Override public btContactSolverInfoFloatData getPointer(long i) { + return new btContactSolverInfoFloatData((Pointer)this).offsetAddress(i); + } + + public native float m_tau(); public native btContactSolverInfoFloatData m_tau(float setter); + public native float m_damping(); public native btContactSolverInfoFloatData m_damping(float setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native float m_friction(); public native btContactSolverInfoFloatData m_friction(float setter); + public native float m_timeStep(); public native btContactSolverInfoFloatData m_timeStep(float setter); + + public native float m_restitution(); public native btContactSolverInfoFloatData m_restitution(float setter); + public native float m_maxErrorReduction(); public native btContactSolverInfoFloatData m_maxErrorReduction(float setter); + public native float m_sor(); public native btContactSolverInfoFloatData m_sor(float setter); + public native float m_erp(); public native btContactSolverInfoFloatData m_erp(float setter); //used as Baumgarte factor + + public native float m_erp2(); public native btContactSolverInfoFloatData m_erp2(float setter); //used in Split Impulse + public native float m_globalCfm(); public native btContactSolverInfoFloatData m_globalCfm(float setter); //constraint force mixing + public native float m_splitImpulsePenetrationThreshold(); public native btContactSolverInfoFloatData m_splitImpulsePenetrationThreshold(float setter); + public native float m_splitImpulseTurnErp(); public native btContactSolverInfoFloatData m_splitImpulseTurnErp(float setter); + + public native float m_linearSlop(); public native btContactSolverInfoFloatData m_linearSlop(float setter); + public native float m_warmstartingFactor(); public native btContactSolverInfoFloatData m_warmstartingFactor(float setter); + public native float m_articulatedWarmstartingFactor(); public native btContactSolverInfoFloatData m_articulatedWarmstartingFactor(float setter); + public native float m_maxGyroscopicForce(); public native btContactSolverInfoFloatData m_maxGyroscopicForce(float setter); + + public native float m_singleAxisRollingFrictionThreshold(); public native btContactSolverInfoFloatData m_singleAxisRollingFrictionThreshold(float setter); + public native int m_numIterations(); public native btContactSolverInfoFloatData m_numIterations(int setter); + public native int m_solverMode(); public native btContactSolverInfoFloatData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native btContactSolverInfoFloatData m_restingContactRestitutionThreshold(int setter); + + public native int m_minimumSolverBatchSize(); public native btContactSolverInfoFloatData m_minimumSolverBatchSize(int setter); + public native int m_splitImpulse(); public native btContactSolverInfoFloatData m_splitImpulse(int setter); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDefaultVehicleRaycaster.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDefaultVehicleRaycaster.java new file mode 100644 index 00000000000..1de6e1524a6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDefaultVehicleRaycaster.java @@ -0,0 +1,28 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btDefaultVehicleRaycaster extends btVehicleRaycaster { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultVehicleRaycaster(Pointer p) { super(p); } + + public btDefaultVehicleRaycaster(btDynamicsWorld world) { super((Pointer)null); allocate(world); } + private native void allocate(btDynamicsWorld world); + + public native Pointer castRay(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @ByRef btVehicleRaycasterResult result); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java new file mode 100644 index 00000000000..d3541154207 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java @@ -0,0 +1,121 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**btDiscreteDynamicsWorld provides discrete rigid body simulation + * those classes replace the obsolete CcdPhysicsEnvironment/CcdPhysicsController */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btDiscreteDynamicsWorld extends btDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDiscreteDynamicsWorld(Pointer p) { super(p); } + + + /**this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those */ + public btDiscreteDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); + + /**if maxSubSteps > 0, it will interpolate motion between fixedTimeStep's */ + public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); + public native int stepSimulation(@Cast("btScalar") float timeStep); + + public native void solveConstraints(@ByRef btContactSolverInfo solverInfo); + + public native void synchronizeMotionStates(); + + /**this can be useful to synchronize a single rigid body -> graphics object */ + public native void synchronizeSingleMotionState(btRigidBody body); + + public native void addConstraint(btTypedConstraint constraint, @Cast("bool") boolean disableCollisionsBetweenLinkedBodies/*=false*/); + public native void addConstraint(btTypedConstraint constraint); + + public native void removeConstraint(btTypedConstraint constraint); + + public native void addAction(btActionInterface arg0); + + public native void removeAction(btActionInterface arg0); + + public native btSimulationIslandManager getSimulationIslandManager(); + + public native btCollisionWorld getCollisionWorld(); + + public native void setGravity(@Const @ByRef btVector3 gravity); + + public native @ByVal btVector3 getGravity(); + + public native void addCollisionObject(btCollisionObject collisionObject, int collisionFilterGroup/*=btBroadphaseProxy::StaticFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter ^ btBroadphaseProxy::StaticFilter*/); + public native void addCollisionObject(btCollisionObject collisionObject); + + public native void addRigidBody(btRigidBody body); + + public native void addRigidBody(btRigidBody body, int group, int mask); + + public native void removeRigidBody(btRigidBody body); + + /**removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject */ + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native void debugDrawConstraint(btTypedConstraint constraint); + + public native void debugDrawWorld(); + + public native void setConstraintSolver(btConstraintSolver solver); + + public native btConstraintSolver getConstraintSolver(); + + public native int getNumConstraints(); + + public native btTypedConstraint getConstraint(int index); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + /**the forces on each rigidbody is accumulating together with gravity. clear this after each timestep. */ + public native void clearForces(); + + /**apply gravity, call this once per timestep */ + public native void applyGravity(); + + public native void setNumTasks(int numTasks); + + /**obsolete, use updateActions instead */ + public native void updateVehicles(@Cast("btScalar") float timeStep); + + /**obsolete, use addAction instead */ + public native void addVehicle(btActionInterface vehicle); + /**obsolete, use removeAction instead */ + public native void removeVehicle(btActionInterface vehicle); + /**obsolete, use addAction instead */ + public native void addCharacter(btActionInterface character); + /**obsolete, use removeAction instead */ + public native void removeCharacter(btActionInterface character); + + public native void setSynchronizeAllMotionStates(@Cast("bool") boolean synchronizeAll); + public native @Cast("bool") boolean getSynchronizeAllMotionStates(); + + public native void setApplySpeculativeContactRestitution(@Cast("bool") boolean enable); + + public native @Cast("bool") boolean getApplySpeculativeContactRestitution(); + + /**Preliminary serialization test for Bullet 2.76. Loading those files requires a separate parser (see Bullet/Demos/SerializeDemo) */ + public native void serialize(btSerializer serializer); + + /**Interpolate motion state between previous and current transform, instead of current and next transform. + * This can relieve discontinuities in the rendering, due to penetrations */ + public native void setLatencyMotionStateInterpolation(@Cast("bool") boolean latencyInterpolation); + public native @Cast("bool") boolean getLatencyMotionStateInterpolation(); + + public native @ByRef btAlignedObjectArray_btRigidBodyPointer getNonStaticRigidBodies(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java new file mode 100644 index 00000000000..01ec41b9fa5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**The btDynamicsWorld is the interface class for several dynamics implementation, basic, discrete, parallel, and continuous etc. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btDynamicsWorld extends btCollisionWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDynamicsWorld(Pointer p) { super(p); } + + + /**stepSimulation proceeds the simulation over 'timeStep', units in preferably in seconds. + * By default, Bullet will subdivide the timestep in constant substeps of each 'fixedTimeStep'. + * in order to keep the simulation real-time, the maximum number of substeps can be clamped to 'maxSubSteps'. + * You can disable subdividing the timestep/substepping by passing maxSubSteps=0 as second argument to stepSimulation, but in that case you have to keep the timeStep constant. */ + public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); + public native int stepSimulation(@Cast("btScalar") float timeStep); + + public native void debugDrawWorld(); + + public native void addConstraint(btTypedConstraint constraint, @Cast("bool") boolean disableCollisionsBetweenLinkedBodies/*=false*/); + public native void addConstraint(btTypedConstraint constraint); + + public native void removeConstraint(btTypedConstraint constraint); + + public native void addAction(btActionInterface action); + + public native void removeAction(btActionInterface action); + + //once a rigidbody is added to the dynamics world, it will get this gravity assigned + //existing rigidbodies in the world get gravity assigned too, during this method + public native void setGravity(@Const @ByRef btVector3 gravity); + public native @ByVal btVector3 getGravity(); + + public native void synchronizeMotionStates(); + + public native void addRigidBody(btRigidBody body); + + public native void addRigidBody(btRigidBody body, int group, int mask); + + public native void removeRigidBody(btRigidBody body); + + public native void setConstraintSolver(btConstraintSolver solver); + + public native btConstraintSolver getConstraintSolver(); + + public native int getNumConstraints(); + + public native btTypedConstraint getConstraint(int index); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + public native void clearForces(); + + /** Set the callback for when an internal tick (simulation substep) happens, optional user info */ + public native void setInternalTickCallback(btInternalTickCallback cb, Pointer worldUserInfo/*=0*/, @Cast("bool") boolean isPreTick/*=false*/); + public native void setInternalTickCallback(btInternalTickCallback cb); + + public native void setWorldUserInfo(Pointer worldUserInfo); + + public native Pointer getWorldUserInfo(); + + public native @ByRef btContactSolverInfo getSolverInfo(); + + /**obsolete, use addAction instead. */ + public native void addVehicle(btActionInterface vehicle); + /**obsolete, use removeAction instead */ + public native void removeVehicle(btActionInterface vehicle); + /**obsolete, use addAction instead. */ + public native void addCharacter(btActionInterface character); + /**obsolete, use removeAction instead */ + public native void removeCharacter(btActionInterface character); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldDoubleData.java new file mode 100644 index 00000000000..318ba38ca78 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldDoubleData.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btDynamicsWorldDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btDynamicsWorldDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDynamicsWorldDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDynamicsWorldDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btDynamicsWorldDoubleData position(long position) { + return (btDynamicsWorldDoubleData)super.position(position); + } + @Override public btDynamicsWorldDoubleData getPointer(long i) { + return new btDynamicsWorldDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btContactSolverInfoDoubleData m_solverInfo(); public native btDynamicsWorldDoubleData m_solverInfo(btContactSolverInfoDoubleData setter); + public native @ByRef btVector3DoubleData m_gravity(); public native btDynamicsWorldDoubleData m_gravity(btVector3DoubleData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldFloatData.java new file mode 100644 index 00000000000..c9146ed13a9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldFloatData.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btDynamicsWorldFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btDynamicsWorldFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDynamicsWorldFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDynamicsWorldFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btDynamicsWorldFloatData position(long position) { + return (btDynamicsWorldFloatData)super.position(position); + } + @Override public btDynamicsWorldFloatData getPointer(long i) { + return new btDynamicsWorldFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btContactSolverInfoFloatData m_solverInfo(); public native btDynamicsWorldFloatData m_solverInfo(btContactSolverInfoFloatData setter); + public native @ByRef btVector3FloatData m_gravity(); public native btDynamicsWorldFloatData m_gravity(btVector3FloatData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java new file mode 100644 index 00000000000..0a5748f6b19 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btFixedConstraint extends btGeneric6DofSpring2Constraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btFixedConstraint(Pointer p) { super(p); } + + public btFixedConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java new file mode 100644 index 00000000000..afbfa2b9265 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif //BT_USE_DOUBLE_PRECISION + +/**The btGeatConstraint will couple the angular velocity for two bodies around given local axis and ratio. + * See Bullet/Demos/ConstraintDemo for an example use. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGearConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGearConstraint(Pointer p) { super(p); } + + public btGearConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("btScalar") float ratio/*=1.f*/) { super((Pointer)null); allocate(rbA, rbB, axisInA, axisInB, ratio); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("btScalar") float ratio/*=1.f*/); + public btGearConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, axisInA, axisInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); + + /**internal method used by the constraint solver, don't use them directly */ + + /**internal method used by the constraint solver, don't use them directly */ + + public native void setAxisA(@ByRef btVector3 axisA); + public native void setAxisB(@ByRef btVector3 axisB); + public native void setRatio(@Cast("btScalar") float ratio); + public native @Const @ByRef btVector3 getAxisA(); + public native @Const @ByRef btVector3 getAxisB(); + public native @Cast("btScalar") float getRatio(); + + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java new file mode 100644 index 00000000000..bcddcd25f0b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGearConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGearConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGearConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGearConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGearConstraintDoubleData position(long position) { + return (btGearConstraintDoubleData)super.position(position); + } + @Override public btGearConstraintDoubleData getPointer(long i) { + return new btGearConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + + public native @ByRef btVector3DoubleData m_axisInA(); public native btGearConstraintDoubleData m_axisInA(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_axisInB(); public native btGearConstraintDoubleData m_axisInB(btVector3DoubleData setter); + + public native double m_ratio(); public native btGearConstraintDoubleData m_ratio(double setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java new file mode 100644 index 00000000000..a93bc81c742 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGearConstraintFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGearConstraintFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGearConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGearConstraintFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGearConstraintFloatData position(long position) { + return (btGearConstraintFloatData)super.position(position); + } + @Override public btGearConstraintFloatData getPointer(long i) { + return new btGearConstraintFloatData((Pointer)this).offsetAddress(i); + } + + + + public native @ByRef btVector3FloatData m_axisInA(); public native btGearConstraintFloatData m_axisInA(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_axisInB(); public native btGearConstraintFloatData m_axisInB(btVector3FloatData setter); + + public native float m_ratio(); public native btGearConstraintFloatData m_ratio(float setter); + public native @Cast("char") byte m_padding(int i); public native btGearConstraintFloatData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java new file mode 100644 index 00000000000..396c34c82d3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java @@ -0,0 +1,185 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + // bits per axis + +/** btGeneric6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space +/** +btGeneric6DofConstraint can leave any of the 6 degree of freedom 'free' or 'locked'. +currently this limit supports rotational motors
+

    +
  • For Linear limits, use btGeneric6DofConstraint.setLinearUpperLimit, btGeneric6DofConstraint.setLinearLowerLimit. You can set the parameters with the btTranslationalLimitMotor structure accsesible through the btGeneric6DofConstraint.getTranslationalLimitMotor method. +At this moment translational motors are not supported. May be in the future.
    • +

    +

  • For Angular limits, use the btRotationalLimitMotor structure for configuring the limit. +This is accessible through btGeneric6DofConstraint.getLimitMotor method, +This brings support for limit parameters and motors.
    • +

    +

  • Angulars limits have these possible ranges: + + + + + + + + + + + + + + + + + + +
    AXISMIN ANGLEMAX ANGLE
    X-PIPI
    Y-PI/2PI/2
    Z-PIPI
    +
    • +
+

+*/ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofConstraint(Pointer p) { super(p); } + + + /**for backwards compatibility during the transition to 'getInfo/getInfo2' */ + public native @Cast("bool") boolean m_useSolveConstraintObsolete(); public native btGeneric6DofConstraint m_useSolveConstraintObsolete(boolean setter); + + public btGeneric6DofConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); + public btGeneric6DofConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameB); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB); + + /** Calcs global transform of the offsets + /** + Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies. + @see btGeneric6DofConstraint.getCalculatedTransformA , btGeneric6DofConstraint.getCalculatedTransformB, btGeneric6DofConstraint.calculateAngleInfo + */ + public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + + public native void calculateTransforms(); + + /** Gets the global transform of the offset for body A + /** + @see btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo. + */ + public native @Const @ByRef btTransform getCalculatedTransformA(); + + /** Gets the global transform of the offset for body B + /** + @see btGeneric6DofConstraint.getFrameOffsetA, btGeneric6DofConstraint.getFrameOffsetB, btGeneric6DofConstraint.calculateAngleInfo. + */ + public native @Const @ByRef btTransform getCalculatedTransformB(); + + public native @ByRef btTransform getFrameOffsetA(); + + public native @ByRef btTransform getFrameOffsetB(); + + /** performs Jacobian calculation, and also calculates angle differences and axis */ + public native void buildJacobian(); + + public native void updateRHS(@Cast("btScalar") float timeStep); + + /** Get the rotation axis in global coordinates + /** + \pre btGeneric6DofConstraint.buildJacobian must be called previously. + */ + public native @ByVal btVector3 getAxis(int axis_index); + + /** Get the relative Euler angle + /** + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("btScalar") float getAngle(int axis_index); + + /** Get the relative position of the constraint pivot + /** + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("btScalar") float getRelativePivotPosition(int axis_index); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + /** Test angular limit. + /** + Calculates angular correction and returns true if limit needs to be corrected. + \pre btGeneric6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("bool") boolean testAngularLimitMotor(int axis_index); + + public native void setLinearLowerLimit(@Const @ByRef btVector3 linearLower); + + public native void getLinearLowerLimit(@ByRef btVector3 linearLower); + + public native void setLinearUpperLimit(@Const @ByRef btVector3 linearUpper); + + public native void getLinearUpperLimit(@ByRef btVector3 linearUpper); + + public native void setAngularLowerLimit(@Const @ByRef btVector3 angularLower); + + public native void getAngularLowerLimit(@ByRef btVector3 angularLower); + + public native void setAngularUpperLimit(@Const @ByRef btVector3 angularUpper); + + public native void getAngularUpperLimit(@ByRef btVector3 angularUpper); + + /** Retrieves the angular limit informacion */ + public native btRotationalLimitMotor getRotationalLimitMotor(int index); + + /** Retrieves the limit informacion */ + public native btTranslationalLimitMotor getTranslationalLimitMotor(); + + //first 3 are linear, next 3 are angular + public native void setLimit(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); + + /** Test limit + /** + - free means upper < lower, + - locked means upper == lower + - limited means upper > lower + - limitIndex: first 3 are linear, next 3 are angular + */ + public native @Cast("bool") boolean isLimited(int limitIndex); + + public native void calcAnchorPos(); // overridable + + // access for UseFrameOffset + public native @Cast("bool") boolean getUseFrameOffset(); + public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); + + public native @Cast("bool") boolean getUseLinearReferenceFrameA(); + public native void setUseLinearReferenceFrameA(@Cast("bool") boolean linearReferenceFrameA); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java new file mode 100644 index 00000000000..dfb2428d8f2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofConstraintData position(long position) { + return (btGeneric6DofConstraintData)super.position(position); + } + @Override public btGeneric6DofConstraintData getPointer(long i) { + return new btGeneric6DofConstraintData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btGeneric6DofConstraintData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformFloatData m_rbBFrame(); public native btGeneric6DofConstraintData m_rbBFrame(btTransformFloatData setter); + + public native @ByRef btVector3FloatData m_linearUpperLimit(); public native btGeneric6DofConstraintData m_linearUpperLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearLowerLimit(); public native btGeneric6DofConstraintData m_linearLowerLimit(btVector3FloatData setter); + + public native @ByRef btVector3FloatData m_angularUpperLimit(); public native btGeneric6DofConstraintData m_angularUpperLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularLowerLimit(); public native btGeneric6DofConstraintData m_angularLowerLimit(btVector3FloatData setter); + + public native int m_useLinearReferenceFrameA(); public native btGeneric6DofConstraintData m_useLinearReferenceFrameA(int setter); + public native int m_useOffsetForConstraintFrame(); public native btGeneric6DofConstraintData m_useOffsetForConstraintFrame(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java new file mode 100644 index 00000000000..ff50cce2893 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofConstraintDoubleData2 position(long position) { + return (btGeneric6DofConstraintDoubleData2)super.position(position); + } + @Override public btGeneric6DofConstraintDoubleData2 getPointer(long i) { + return new btGeneric6DofConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btGeneric6DofConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btGeneric6DofConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); + + public native @ByRef btVector3DoubleData m_linearUpperLimit(); public native btGeneric6DofConstraintDoubleData2 m_linearUpperLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearLowerLimit(); public native btGeneric6DofConstraintDoubleData2 m_linearLowerLimit(btVector3DoubleData setter); + + public native @ByRef btVector3DoubleData m_angularUpperLimit(); public native btGeneric6DofConstraintDoubleData2 m_angularUpperLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularLowerLimit(); public native btGeneric6DofConstraintDoubleData2 m_angularLowerLimit(btVector3DoubleData setter); + + public native int m_useLinearReferenceFrameA(); public native btGeneric6DofConstraintDoubleData2 m_useLinearReferenceFrameA(int setter); + public native int m_useOffsetForConstraintFrame(); public native btGeneric6DofConstraintDoubleData2 m_useOffsetForConstraintFrame(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java new file mode 100644 index 00000000000..9d02fbca08f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java @@ -0,0 +1,129 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + // bits per axis + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofSpring2Constraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpring2Constraint(Pointer p) { super(p); } + + + public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, rotOrder); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/); + public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB); + public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/) { super((Pointer)null); allocate(rbB, frameInB, rotOrder); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("RotateOrder") int rotOrder/*=RO_XYZ*/); + public btGeneric6DofSpring2Constraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB) { super((Pointer)null); allocate(rbB, frameInB); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB); + + public native void buildJacobian(); + public native int calculateSerializeBufferSize(); + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native btRotationalLimitMotor2 getRotationalLimitMotor(int index); + public native btTranslationalLimitMotor2 getTranslationalLimitMotor(); + + // Calculates the global transform for the joint offset for body A an B, and also calculates the angle differences between the bodies. + public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + public native void calculateTransforms(); + + // Gets the global transform of the offset for body A + public native @Const @ByRef btTransform getCalculatedTransformA(); + // Gets the global transform of the offset for body B + public native @Const @ByRef btTransform getCalculatedTransformB(); + + public native @ByRef btTransform getFrameOffsetA(); + public native @ByRef btTransform getFrameOffsetB(); + + // Get the rotation axis in global coordinates ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + public native @ByVal btVector3 getAxis(int axis_index); + + // Get the relative Euler angle ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + public native @Cast("btScalar") float getAngle(int axis_index); + + // Get the relative position of the constraint pivot ( btGeneric6DofSpring2Constraint::calculateTransforms() must be called previously ) + public native @Cast("btScalar") float getRelativePivotPosition(int axis_index); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + public native void setLinearLowerLimit(@Const @ByRef btVector3 linearLower); + public native void getLinearLowerLimit(@ByRef btVector3 linearLower); + public native void setLinearUpperLimit(@Const @ByRef btVector3 linearUpper); + public native void getLinearUpperLimit(@ByRef btVector3 linearUpper); + + public native void setAngularLowerLimit(@Const @ByRef btVector3 angularLower); + + public native void setAngularLowerLimitReversed(@Const @ByRef btVector3 angularLower); + + public native void getAngularLowerLimit(@ByRef btVector3 angularLower); + + public native void getAngularLowerLimitReversed(@ByRef btVector3 angularLower); + + public native void setAngularUpperLimit(@Const @ByRef btVector3 angularUpper); + + public native void setAngularUpperLimitReversed(@Const @ByRef btVector3 angularUpper); + + public native void getAngularUpperLimit(@ByRef btVector3 angularUpper); + + public native void getAngularUpperLimitReversed(@ByRef btVector3 angularUpper); + + //first 3 are linear, next 3 are angular + + public native void setLimit(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); + + public native void setLimitReversed(int axis, @Cast("btScalar") float lo, @Cast("btScalar") float hi); + + public native @Cast("bool") boolean isLimited(int limitIndex); + + public native void setRotationOrder(@Cast("RotateOrder") int order); + public native @Cast("RotateOrder") int getRotationOrder(); + + public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + + public native void setBounce(int index, @Cast("btScalar") float bounce); + + public native void enableMotor(int index, @Cast("bool") boolean onOff); + public native void setServo(int index, @Cast("bool") boolean onOff); // set the type of the motor (servo or not) (the motor has to be turned on for servo also) + public native void setTargetVelocity(int index, @Cast("btScalar") float velocity); + public native void setServoTarget(int index, @Cast("btScalar") float target); + public native void setMaxMotorForce(int index, @Cast("btScalar") float force); + + public native void enableSpring(int index, @Cast("bool") boolean onOff); + public native void setStiffness(int index, @Cast("btScalar") float stiffness, @Cast("bool") boolean limitIfNeeded/*=true*/); + public native void setStiffness(int index, @Cast("btScalar") float stiffness); // if limitIfNeeded is true the system will automatically limit the stiffness in necessary situations where otherwise the spring would move unrealistically too widely + public native void setDamping(int index, @Cast("btScalar") float damping, @Cast("bool") boolean limitIfNeeded/*=true*/); + public native void setDamping(int index, @Cast("btScalar") float damping); // if limitIfNeeded is true the system will automatically limit the damping in necessary situations where otherwise the spring would blow up + public native void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF + public native void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF + public native void setEquilibriumPoint(int index, @Cast("btScalar") float val); + + //override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + //If no axis is provided, it uses the default axis for this constraint. + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public static native @Cast("btScalar") float btGetMatrixElem(@Const @ByRef btMatrix3x3 mat, int index); + public static native @Cast("bool") boolean matrixToEulerXYZ(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerXZY(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerYXZ(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerYZX(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerZXY(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); + public static native @Cast("bool") boolean matrixToEulerZYX(@Const @ByRef btMatrix3x3 mat, @ByRef btVector3 xyz); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java new file mode 100644 index 00000000000..314333500a4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofSpring2ConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofSpring2ConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofSpring2ConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpring2ConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofSpring2ConstraintData position(long position) { + return (btGeneric6DofSpring2ConstraintData)super.position(position); + } + @Override public btGeneric6DofSpring2ConstraintData getPointer(long i) { + return new btGeneric6DofSpring2ConstraintData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btGeneric6DofSpring2ConstraintData m_rbAFrame(btTransformFloatData setter); + public native @ByRef btTransformFloatData m_rbBFrame(); public native btGeneric6DofSpring2ConstraintData m_rbBFrame(btTransformFloatData setter); + + public native @ByRef btVector3FloatData m_linearUpperLimit(); public native btGeneric6DofSpring2ConstraintData m_linearUpperLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearLowerLimit(); public native btGeneric6DofSpring2ConstraintData m_linearLowerLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearBounce(); public native btGeneric6DofSpring2ConstraintData m_linearBounce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearStopERP(); public native btGeneric6DofSpring2ConstraintData m_linearStopERP(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearStopCFM(); public native btGeneric6DofSpring2ConstraintData m_linearStopCFM(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearMotorERP(); public native btGeneric6DofSpring2ConstraintData m_linearMotorERP(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearMotorCFM(); public native btGeneric6DofSpring2ConstraintData m_linearMotorCFM(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearTargetVelocity(); public native btGeneric6DofSpring2ConstraintData m_linearTargetVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearMaxMotorForce(); public native btGeneric6DofSpring2ConstraintData m_linearMaxMotorForce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearServoTarget(); public native btGeneric6DofSpring2ConstraintData m_linearServoTarget(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearSpringStiffness(); public native btGeneric6DofSpring2ConstraintData m_linearSpringStiffness(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearSpringDamping(); public native btGeneric6DofSpring2ConstraintData m_linearSpringDamping(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintData m_linearEquilibriumPoint(btVector3FloatData setter); + public native @Cast("char") byte m_linearEnableMotor(int i); public native btGeneric6DofSpring2ConstraintData m_linearEnableMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearEnableMotor(); + public native @Cast("char") byte m_linearServoMotor(int i); public native btGeneric6DofSpring2ConstraintData m_linearServoMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearServoMotor(); + public native @Cast("char") byte m_linearEnableSpring(int i); public native btGeneric6DofSpring2ConstraintData m_linearEnableSpring(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearEnableSpring(); + public native @Cast("char") byte m_linearSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintData m_linearSpringStiffnessLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearSpringStiffnessLimited(); + public native @Cast("char") byte m_linearSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintData m_linearSpringDampingLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearSpringDampingLimited(); + public native @Cast("char") byte m_padding1(int i); public native btGeneric6DofSpring2ConstraintData m_padding1(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding1(); + + public native @ByRef btVector3FloatData m_angularUpperLimit(); public native btGeneric6DofSpring2ConstraintData m_angularUpperLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularLowerLimit(); public native btGeneric6DofSpring2ConstraintData m_angularLowerLimit(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularBounce(); public native btGeneric6DofSpring2ConstraintData m_angularBounce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularStopERP(); public native btGeneric6DofSpring2ConstraintData m_angularStopERP(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularStopCFM(); public native btGeneric6DofSpring2ConstraintData m_angularStopCFM(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularMotorERP(); public native btGeneric6DofSpring2ConstraintData m_angularMotorERP(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularMotorCFM(); public native btGeneric6DofSpring2ConstraintData m_angularMotorCFM(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularTargetVelocity(); public native btGeneric6DofSpring2ConstraintData m_angularTargetVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularMaxMotorForce(); public native btGeneric6DofSpring2ConstraintData m_angularMaxMotorForce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularServoTarget(); public native btGeneric6DofSpring2ConstraintData m_angularServoTarget(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularSpringStiffness(); public native btGeneric6DofSpring2ConstraintData m_angularSpringStiffness(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularSpringDamping(); public native btGeneric6DofSpring2ConstraintData m_angularSpringDamping(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintData m_angularEquilibriumPoint(btVector3FloatData setter); + public native @Cast("char") byte m_angularEnableMotor(int i); public native btGeneric6DofSpring2ConstraintData m_angularEnableMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularEnableMotor(); + public native @Cast("char") byte m_angularServoMotor(int i); public native btGeneric6DofSpring2ConstraintData m_angularServoMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularServoMotor(); + public native @Cast("char") byte m_angularEnableSpring(int i); public native btGeneric6DofSpring2ConstraintData m_angularEnableSpring(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularEnableSpring(); + public native @Cast("char") byte m_angularSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintData m_angularSpringStiffnessLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularSpringStiffnessLimited(); + public native @Cast("char") byte m_angularSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintData m_angularSpringDampingLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularSpringDampingLimited(); + + public native int m_rotateOrder(); public native btGeneric6DofSpring2ConstraintData m_rotateOrder(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java new file mode 100644 index 00000000000..231f7755403 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofSpring2ConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofSpring2ConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofSpring2ConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpring2ConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofSpring2ConstraintDoubleData2 position(long position) { + return (btGeneric6DofSpring2ConstraintDoubleData2)super.position(position); + } + @Override public btGeneric6DofSpring2ConstraintDoubleData2 getPointer(long i) { + return new btGeneric6DofSpring2ConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); + + public native @ByRef btVector3DoubleData m_linearUpperLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearUpperLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearLowerLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearLowerLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearBounce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearBounce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearStopERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearStopERP(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearStopCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearStopCFM(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearMotorERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMotorERP(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearMotorCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMotorCFM(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearTargetVelocity(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearTargetVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearMaxMotorForce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearMaxMotorForce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearServoTarget(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearServoTarget(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearSpringStiffness(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringStiffness(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearSpringDamping(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringDamping(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEquilibriumPoint(btVector3DoubleData setter); + public native @Cast("char") byte m_linearEnableMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEnableMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearEnableMotor(); + public native @Cast("char") byte m_linearServoMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearServoMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearServoMotor(); + public native @Cast("char") byte m_linearEnableSpring(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearEnableSpring(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearEnableSpring(); + public native @Cast("char") byte m_linearSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringStiffnessLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearSpringStiffnessLimited(); + public native @Cast("char") byte m_linearSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_linearSpringDampingLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_linearSpringDampingLimited(); + public native @Cast("char") byte m_padding1(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_padding1(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding1(); + + public native @ByRef btVector3DoubleData m_angularUpperLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularUpperLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularLowerLimit(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularLowerLimit(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularBounce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularBounce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularStopERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularStopERP(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularStopCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularStopCFM(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularMotorERP(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMotorERP(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularMotorCFM(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMotorCFM(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularTargetVelocity(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularTargetVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularMaxMotorForce(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularMaxMotorForce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularServoTarget(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularServoTarget(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularSpringStiffness(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringStiffness(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularSpringDamping(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringDamping(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularEquilibriumPoint(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEquilibriumPoint(btVector3DoubleData setter); + public native @Cast("char") byte m_angularEnableMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEnableMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularEnableMotor(); + public native @Cast("char") byte m_angularServoMotor(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularServoMotor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularServoMotor(); + public native @Cast("char") byte m_angularEnableSpring(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularEnableSpring(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularEnableSpring(); + public native @Cast("char") byte m_angularSpringStiffnessLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringStiffnessLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularSpringStiffnessLimited(); + public native @Cast("char") byte m_angularSpringDampingLimited(int i); public native btGeneric6DofSpring2ConstraintDoubleData2 m_angularSpringDampingLimited(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_angularSpringDampingLimited(); + + public native int m_rotateOrder(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rotateOrder(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java new file mode 100644 index 00000000000..0c1594613c2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java @@ -0,0 +1,60 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif //BT_USE_DOUBLE_PRECISION + +/** Generic 6 DOF constraint that allows to set spring motors to any translational and rotational DOF +

+ * DOF index used in enableSpring() and setStiffness() means: + * 0 : translation X + * 1 : translation Y + * 2 : translation Z + * 3 : rotation X (3rd Euler rotational around new position of X axis, range [-PI+epsilon, PI-epsilon] ) + * 4 : rotation Y (2nd Euler rotational around new position of Y axis, range [-PI/2+epsilon, PI/2-epsilon] ) + * 5 : rotation Z (1st Euler rotational around Z axis, range [-PI+epsilon, PI-epsilon] ) */ + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofSpringConstraint extends btGeneric6DofConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpringConstraint(Pointer p) { super(p); } + + + public btGeneric6DofSpringConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); + public btGeneric6DofSpringConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameB); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameB); + public native void enableSpring(int index, @Cast("bool") boolean onOff); + public native void setStiffness(int index, @Cast("btScalar") float stiffness); + public native void setDamping(int index, @Cast("btScalar") float damping); + public native void setEquilibriumPoint(); // set the current constraint position/orientation as an equilibrium point for all DOF + public native void setEquilibriumPoint(int index); // set the current constraint position/orientation as an equilibrium point for given DOF + public native void setEquilibriumPoint(int index, @Cast("btScalar") float val); + + public native @Cast("bool") boolean isSpringEnabled(int index); + + public native @Cast("btScalar") float getStiffness(int index); + + public native @Cast("btScalar") float getDamping(int index); + + public native @Cast("btScalar") float getEquilibriumPoint(int index); + + public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + + public native int calculateSerializeBufferSize(); + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintData.java new file mode 100644 index 00000000000..22efbf85a27 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintData.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofSpringConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofSpringConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofSpringConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpringConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofSpringConstraintData position(long position) { + return (btGeneric6DofSpringConstraintData)super.position(position); + } + @Override public btGeneric6DofSpringConstraintData getPointer(long i) { + return new btGeneric6DofSpringConstraintData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btGeneric6DofConstraintData m_6dofData(); public native btGeneric6DofSpringConstraintData m_6dofData(btGeneric6DofConstraintData setter); + + public native int m_springEnabled(int i); public native btGeneric6DofSpringConstraintData m_springEnabled(int i, int setter); + @MemberGetter public native IntPointer m_springEnabled(); + public native float m_equilibriumPoint(int i); public native btGeneric6DofSpringConstraintData m_equilibriumPoint(int i, float setter); + @MemberGetter public native FloatPointer m_equilibriumPoint(); + public native float m_springStiffness(int i); public native btGeneric6DofSpringConstraintData m_springStiffness(int i, float setter); + @MemberGetter public native FloatPointer m_springStiffness(); + public native float m_springDamping(int i); public native btGeneric6DofSpringConstraintData m_springDamping(int i, float setter); + @MemberGetter public native FloatPointer m_springDamping(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java new file mode 100644 index 00000000000..21b63560f8e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btGeneric6DofSpringConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeneric6DofSpringConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeneric6DofSpringConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpringConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeneric6DofSpringConstraintDoubleData2 position(long position) { + return (btGeneric6DofSpringConstraintDoubleData2)super.position(position); + } + @Override public btGeneric6DofSpringConstraintDoubleData2 getPointer(long i) { + return new btGeneric6DofSpringConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + public native @ByRef btGeneric6DofConstraintDoubleData2 m_6dofData(); public native btGeneric6DofSpringConstraintDoubleData2 m_6dofData(btGeneric6DofConstraintDoubleData2 setter); + + public native int m_springEnabled(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springEnabled(int i, int setter); + @MemberGetter public native IntPointer m_springEnabled(); + public native double m_equilibriumPoint(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_equilibriumPoint(int i, double setter); + @MemberGetter public native DoublePointer m_equilibriumPoint(); + public native double m_springStiffness(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springStiffness(int i, double setter); + @MemberGetter public native DoublePointer m_springStiffness(); + public native double m_springDamping(int i); public native btGeneric6DofSpringConstraintDoubleData2 m_springDamping(int i, double setter); + @MemberGetter public native DoublePointer m_springDamping(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java new file mode 100644 index 00000000000..f1bc6739c22 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +// Constraint similar to ODE Hinge2 Joint +// has 3 degrees of frredom: +// 2 rotational degrees of freedom, similar to Euler rotations around Z (axis 1) and X (axis 2) +// 1 translational (along axis Z) with suspension spring + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btHinge2Constraint extends btGeneric6DofSpring2Constraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHinge2Constraint(Pointer p) { super(p); } + + + // constructor + // anchor, axis1 and axis2 are in world coordinate system + // axis1 must be orthogonal to axis2 + public btHinge2Constraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @ByRef btVector3 anchor, @ByRef btVector3 axis1, @ByRef btVector3 axis2) { super((Pointer)null); allocate(rbA, rbB, anchor, axis1, axis2); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @ByRef btVector3 anchor, @ByRef btVector3 axis1, @ByRef btVector3 axis2); + // access + public native @Const @ByRef btVector3 getAnchor(); + public native @Const @ByRef btVector3 getAnchor2(); + public native @Const @ByRef btVector3 getAxis1(); + public native @Const @ByRef btVector3 getAxis2(); + public native @Cast("btScalar") float getAngle1(); + public native @Cast("btScalar") float getAngle2(); + // limits + public native void setUpperLimit(@Cast("btScalar") float ang1max); + public native void setLowerLimit(@Cast("btScalar") float ang1min); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java new file mode 100644 index 00000000000..ae1a19613ee --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION + +/**The getAccumulatedHingeAngle returns the accumulated hinge angle, taking rotation across the -PI/PI boundary into account */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btHingeAccumulatedAngleConstraint extends btHingeConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeAccumulatedAngleConstraint(Pointer p) { super(p); } + + + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); + + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, pivotInA, axisInA, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA) { super((Pointer)null); allocate(rbA, pivotInA, axisInA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA); + + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); + + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbAFrame, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeAccumulatedAngleConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); + public native @Cast("btScalar") float getAccumulatedHingeAngle(); + public native void setAccumulatedHingeAngle(@Cast("btScalar") float accAngle); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java new file mode 100644 index 00000000000..093ce92a820 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java @@ -0,0 +1,130 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** hinge constraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space + * axis defines the orientation of the hinge axis */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btHingeConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraint(Pointer p) { super(p); } + + + public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB, axisInA, axisInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); + + public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, pivotInA, axisInA, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA) { super((Pointer)null); allocate(rbA, pivotInA, axisInA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 axisInA); + + public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame) { super((Pointer)null); allocate(rbA, rbB, rbAFrame, rbBFrame); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform rbAFrame, @Const @ByRef btTransform rbBFrame); + + public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/) { super((Pointer)null); allocate(rbA, rbAFrame, useReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame, @Cast("bool") boolean useReferenceFrameA/*=false*/); + public btHingeConstraint(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame) { super((Pointer)null); allocate(rbA, rbAFrame); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); + + public native void buildJacobian(); + + public native void updateRHS(@Cast("btScalar") float timeStep); + + public native @ByRef btRigidBody getRigidBodyA(); + + public native @ByRef btRigidBody getRigidBodyB(); + + public native @ByRef btTransform getFrameOffsetA(); + + public native @ByRef btTransform getFrameOffsetB(); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + public native void setAngularOnly(@Cast("bool") boolean angularOnly); + + public native void enableAngularMotor(@Cast("bool") boolean enableMotor, @Cast("btScalar") float targetVelocity, @Cast("btScalar") float maxMotorImpulse); + + // extra motor API, including ability to set a target rotation (as opposed to angular velocity) + // note: setMotorTarget sets angular velocity under the hood, so you must call it every tick to + // maintain a given angular target. + public native void enableMotor(@Cast("bool") boolean enableMotor); + public native void setMaxMotorImpulse(@Cast("btScalar") float maxMotorImpulse); + public native void setMotorTargetVelocity(@Cast("btScalar") float motorTargetVelocity); + public native void setMotorTarget(@Const @ByRef btQuaternion qAinB, @Cast("btScalar") float dt); // qAinB is rotation of body A wrt body B. + public native void setMotorTarget(@Cast("btScalar") float targetAngle, @Cast("btScalar") float dt); + + public native void setLimit(@Cast("btScalar") float low, @Cast("btScalar") float high, @Cast("btScalar") float _softness/*=0.9f*/, @Cast("btScalar") float _biasFactor/*=0.3f*/, @Cast("btScalar") float _relaxationFactor/*=1.0f*/); + public native void setLimit(@Cast("btScalar") float low, @Cast("btScalar") float high); + + public native @Cast("btScalar") float getLimitSoftness(); + + public native @Cast("btScalar") float getLimitBiasFactor(); + + public native @Cast("btScalar") float getLimitRelaxationFactor(); + + public native void setAxis(@ByRef btVector3 axisInA); + + public native @Cast("bool") boolean hasLimit(); + + public native @Cast("btScalar") float getLowerLimit(); + + public native @Cast("btScalar") float getUpperLimit(); + + /**The getHingeAngle gives the hinge angle in range [-PI,PI] */ + public native @Cast("btScalar") float getHingeAngle(); + + public native @Cast("btScalar") float getHingeAngle(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + + public native void testLimit(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + + public native @ByRef btTransform getAFrame(); + public native @ByRef btTransform getBFrame(); + + public native int getSolveLimit(); + + public native @Cast("btScalar") float getLimitSign(); + + public native @Cast("bool") boolean getAngularOnly(); + public native @Cast("bool") boolean getEnableAngularMotor(); + public native @Cast("btScalar") float getMotorTargetVelocity(); + public native @Cast("btScalar") float getMaxMotorImpulse(); + // access for UseFrameOffset + public native @Cast("bool") boolean getUseFrameOffset(); + public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); + // access for UseReferenceFrameA + public native @Cast("bool") boolean getUseReferenceFrameA(); + public native void setUseReferenceFrameA(@Cast("bool") boolean useReferenceFrameA); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java new file mode 100644 index 00000000000..f0abd3e99f2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java @@ -0,0 +1,53 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +//only for backward compatibility +// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +/**this structure is not used, except for loading pre-2.82 .bullet files */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btHingeConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHingeConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHingeConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHingeConstraintDoubleData position(long position) { + return (btHingeConstraintDoubleData)super.position(position); + } + @Override public btHingeConstraintDoubleData getPointer(long i) { + return new btHingeConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btHingeConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btHingeConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); + public native int m_useReferenceFrameA(); public native btHingeConstraintDoubleData m_useReferenceFrameA(int setter); + public native int m_angularOnly(); public native btHingeConstraintDoubleData m_angularOnly(int setter); + public native int m_enableAngularMotor(); public native btHingeConstraintDoubleData m_enableAngularMotor(int setter); + public native float m_motorTargetVelocity(); public native btHingeConstraintDoubleData m_motorTargetVelocity(float setter); + public native float m_maxMotorImpulse(); public native btHingeConstraintDoubleData m_maxMotorImpulse(float setter); + + public native float m_lowerLimit(); public native btHingeConstraintDoubleData m_lowerLimit(float setter); + public native float m_upperLimit(); public native btHingeConstraintDoubleData m_upperLimit(float setter); + public native float m_limitSoftness(); public native btHingeConstraintDoubleData m_limitSoftness(float setter); + public native float m_biasFactor(); public native btHingeConstraintDoubleData m_biasFactor(float setter); + public native float m_relaxationFactor(); public native btHingeConstraintDoubleData m_relaxationFactor(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java new file mode 100644 index 00000000000..b3f7aceb590 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java @@ -0,0 +1,53 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btHingeConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHingeConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHingeConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHingeConstraintDoubleData2 position(long position) { + return (btHingeConstraintDoubleData2)super.position(position); + } + @Override public btHingeConstraintDoubleData2 getPointer(long i) { + return new btHingeConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btHingeConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btHingeConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); + public native int m_useReferenceFrameA(); public native btHingeConstraintDoubleData2 m_useReferenceFrameA(int setter); + public native int m_angularOnly(); public native btHingeConstraintDoubleData2 m_angularOnly(int setter); + public native int m_enableAngularMotor(); public native btHingeConstraintDoubleData2 m_enableAngularMotor(int setter); + public native double m_motorTargetVelocity(); public native btHingeConstraintDoubleData2 m_motorTargetVelocity(double setter); + public native double m_maxMotorImpulse(); public native btHingeConstraintDoubleData2 m_maxMotorImpulse(double setter); + + public native double m_lowerLimit(); public native btHingeConstraintDoubleData2 m_lowerLimit(double setter); + public native double m_upperLimit(); public native btHingeConstraintDoubleData2 m_upperLimit(double setter); + public native double m_limitSoftness(); public native btHingeConstraintDoubleData2 m_limitSoftness(double setter); + public native double m_biasFactor(); public native btHingeConstraintDoubleData2 m_biasFactor(double setter); + public native double m_relaxationFactor(); public native btHingeConstraintDoubleData2 m_relaxationFactor(double setter); + public native @Cast("char") byte m_padding1(int i); public native btHingeConstraintDoubleData2 m_padding1(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding1(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java new file mode 100644 index 00000000000..15f8119e78a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btHingeConstraintFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHingeConstraintFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHingeConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraintFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHingeConstraintFloatData position(long position) { + return (btHingeConstraintFloatData)super.position(position); + } + @Override public btHingeConstraintFloatData getPointer(long i) { + return new btHingeConstraintFloatData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btHingeConstraintFloatData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformFloatData m_rbBFrame(); public native btHingeConstraintFloatData m_rbBFrame(btTransformFloatData setter); + public native int m_useReferenceFrameA(); public native btHingeConstraintFloatData m_useReferenceFrameA(int setter); + public native int m_angularOnly(); public native btHingeConstraintFloatData m_angularOnly(int setter); + + public native int m_enableAngularMotor(); public native btHingeConstraintFloatData m_enableAngularMotor(int setter); + public native float m_motorTargetVelocity(); public native btHingeConstraintFloatData m_motorTargetVelocity(float setter); + public native float m_maxMotorImpulse(); public native btHingeConstraintFloatData m_maxMotorImpulse(float setter); + + public native float m_lowerLimit(); public native btHingeConstraintFloatData m_lowerLimit(float setter); + public native float m_upperLimit(); public native btHingeConstraintFloatData m_upperLimit(float setter); + public native float m_limitSoftness(); public native btHingeConstraintFloatData m_limitSoftness(float setter); + public native float m_biasFactor(); public native btHingeConstraintFloatData m_biasFactor(float setter); + public native float m_relaxationFactor(); public native btHingeConstraintFloatData m_relaxationFactor(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btInternalTickCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btInternalTickCallback.java new file mode 100644 index 00000000000..e0375aea953 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btInternalTickCallback.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** Type for the callback for each tick */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btInternalTickCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btInternalTickCallback(Pointer p) { super(p); } + protected btInternalTickCallback() { allocate(); } + private native void allocate(); + public native void call(btDynamicsWorld world, @Cast("btScalar") float timeStep); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPersistentManifold.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPersistentManifold.java new file mode 100644 index 00000000000..09aa959a2f0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPersistentManifold.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btPersistentManifold extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btPersistentManifold() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPersistentManifold(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java new file mode 100644 index 00000000000..f79a449ff26 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java @@ -0,0 +1,63 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btPoint2PointConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraint(Pointer p) { super(p); } + + + /**for backwards compatibility during the transition to 'getInfo/getInfo2' */ + public native @Cast("bool") boolean m_useSolveConstraintObsolete(); public native btPoint2PointConstraint m_useSolveConstraintObsolete(boolean setter); + + public native @ByRef btConstraintSetting m_setting(); public native btPoint2PointConstraint m_setting(btConstraintSetting setter); + + public btPoint2PointConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB); + + public btPoint2PointConstraint(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA) { super((Pointer)null); allocate(rbA, pivotInA); } + private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btVector3 pivotInA); + + public native void buildJacobian(); + + public native void updateRHS(@Cast("btScalar") float timeStep); + + public native void setPivotA(@Const @ByRef btVector3 pivotA); + + public native void setPivotB(@Const @ByRef btVector3 pivotB); + + public native @Const @ByRef btVector3 getPivotInA(); + + public native @Const @ByRef btVector3 getPivotInB(); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java new file mode 100644 index 00000000000..e5abb8625d1 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 + * this structure is not used, except for loading pre-2.82 .bullet files + * do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btPoint2PointConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPoint2PointConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPoint2PointConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPoint2PointConstraintDoubleData position(long position) { + return (btPoint2PointConstraintDoubleData)super.position(position); + } + @Override public btPoint2PointConstraintDoubleData getPointer(long i) { + return new btPoint2PointConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btVector3DoubleData m_pivotInA(); public native btPoint2PointConstraintDoubleData m_pivotInA(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_pivotInB(); public native btPoint2PointConstraintDoubleData m_pivotInB(btVector3DoubleData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java new file mode 100644 index 00000000000..01fd9de739f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btPoint2PointConstraintDoubleData2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPoint2PointConstraintDoubleData2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPoint2PointConstraintDoubleData2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraintDoubleData2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPoint2PointConstraintDoubleData2 position(long position) { + return (btPoint2PointConstraintDoubleData2)super.position(position); + } + @Override public btPoint2PointConstraintDoubleData2 getPointer(long i) { + return new btPoint2PointConstraintDoubleData2((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btVector3DoubleData m_pivotInA(); public native btPoint2PointConstraintDoubleData2 m_pivotInA(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_pivotInB(); public native btPoint2PointConstraintDoubleData2 m_pivotInB(btVector3DoubleData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java new file mode 100644 index 00000000000..c86d6d3e51c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btPoint2PointConstraintFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPoint2PointConstraintFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPoint2PointConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraintFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPoint2PointConstraintFloatData position(long position) { + return (btPoint2PointConstraintFloatData)super.position(position); + } + @Override public btPoint2PointConstraintFloatData getPointer(long i) { + return new btPoint2PointConstraintFloatData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btVector3FloatData m_pivotInA(); public native btPoint2PointConstraintFloatData m_pivotInA(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_pivotInB(); public native btPoint2PointConstraintFloatData m_pivotInB(btVector3FloatData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java new file mode 100644 index 00000000000..cfe4aa9e536 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java @@ -0,0 +1,123 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +//class btVehicleTuning; + +/**rayCast vehicle, very special constraint that turn a rigidbody into a vehicle. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btRaycastVehicle extends btActionInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRaycastVehicle(Pointer p) { super(p); } + + @NoOffset public static class btVehicleTuning extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVehicleTuning(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVehicleTuning(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVehicleTuning position(long position) { + return (btVehicleTuning)super.position(position); + } + @Override public btVehicleTuning getPointer(long i) { + return new btVehicleTuning((Pointer)this).offsetAddress(i); + } + + public btVehicleTuning() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float m_suspensionStiffness(); public native btVehicleTuning m_suspensionStiffness(float setter); + public native @Cast("btScalar") float m_suspensionCompression(); public native btVehicleTuning m_suspensionCompression(float setter); + public native @Cast("btScalar") float m_suspensionDamping(); public native btVehicleTuning m_suspensionDamping(float setter); + public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btVehicleTuning m_maxSuspensionTravelCm(float setter); + public native @Cast("btScalar") float m_frictionSlip(); public native btVehicleTuning m_frictionSlip(float setter); + public native @Cast("btScalar") float m_maxSuspensionForce(); public native btVehicleTuning m_maxSuspensionForce(float setter); + } + //constructor to create a car from an existing rigidbody + public btRaycastVehicle(@Const @ByRef btVehicleTuning tuning, btRigidBody chassis, btVehicleRaycaster raycaster) { super((Pointer)null); allocate(tuning, chassis, raycaster); } + private native void allocate(@Const @ByRef btVehicleTuning tuning, btRigidBody chassis, btVehicleRaycaster raycaster); + + /**btActionInterface interface */ + public native void updateAction(btCollisionWorld collisionWorld, @Cast("btScalar") float step); + + /**btActionInterface interface */ + public native void debugDraw(btIDebugDraw debugDrawer); + + public native @Const @ByRef btTransform getChassisWorldTransform(); + + public native @Cast("btScalar") float rayCast(@ByRef btWheelInfo wheel); + + public native void updateVehicle(@Cast("btScalar") float step); + + public native void resetSuspension(); + + public native @Cast("btScalar") float getSteeringValue(int wheel); + + public native void setSteeringValue(@Cast("btScalar") float steering, int wheel); + + public native void applyEngineForce(@Cast("btScalar") float force, int wheel); + + public native @Const @ByRef btTransform getWheelTransformWS(int wheelIndex); + + public native void updateWheelTransform(int wheelIndex, @Cast("bool") boolean interpolatedTransform/*=true*/); + public native void updateWheelTransform(int wheelIndex); + + // void setRaycastWheelInfo( int wheelIndex , bool isInContact, const btVector3& hitPoint, const btVector3& hitNormal,btScalar depth); + + public native @ByRef btWheelInfo addWheel(@Const @ByRef btVector3 connectionPointCS0, @Const @ByRef btVector3 wheelDirectionCS0, @Const @ByRef btVector3 wheelAxleCS, @Cast("btScalar") float suspensionRestLength, @Cast("btScalar") float wheelRadius, @Const @ByRef btVehicleTuning tuning, @Cast("bool") boolean isFrontWheel); + + public native int getNumWheels(); + + + + public native @ByRef btWheelInfo getWheelInfo(int index); + + public native void updateWheelTransformsWS(@ByRef btWheelInfo wheel, @Cast("bool") boolean interpolatedTransform/*=true*/); + public native void updateWheelTransformsWS(@ByRef btWheelInfo wheel); + + public native void setBrake(@Cast("btScalar") float brake, int wheelIndex); + + public native void setPitchControl(@Cast("btScalar") float pitch); + + public native void updateSuspension(@Cast("btScalar") float deltaTime); + + public native void updateFriction(@Cast("btScalar") float timeStep); + + public native btRigidBody getRigidBody(); + + public native int getRightAxis(); + public native int getUpAxis(); + + public native int getForwardAxis(); + + /**Worldspace forward vector */ + public native @ByVal btVector3 getForwardVector(); + + /**Velocity of vehicle (positive if velocity vector has same direction as foward vector) */ + public native @Cast("btScalar") float getCurrentSpeedKmHour(); + + public native void setCoordinateSystem(int rightIndex, int upIndex, int forwardIndex); + + /**backwards compatibility */ + public native int getUserConstraintType(); + + public native void setUserConstraintType(int userConstraintType); + + public native void setUserConstraintId(int uid); + + public native int getUserConstraintId(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java new file mode 100644 index 00000000000..a3167ed0c21 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java @@ -0,0 +1,253 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**The btRigidBody is the main class for rigid body objects. It is derived from btCollisionObject, so it keeps a pointer to a btCollisionShape. + * It is recommended for performance and memory use to share btCollisionShape objects whenever possible. + * There are 3 types of rigid bodies: + * - A) Dynamic rigid bodies, with positive mass. Motion is controlled by rigid body dynamics. + * - B) Fixed objects with zero mass. They are not moving (basically collision objects) + * - C) Kinematic objects, which are objects without mass, but the user can move them. There is one-way interaction, and Bullet calculates a velocity based on the timestep and previous and current world transform. + * Bullet automatically deactivates dynamic rigid bodies, when the velocity is below a threshold for a given time. + * Deactivated (sleeping) rigid bodies don't take any processing time, except a minor broadphase collision detection impact (to allow active objects to activate/wake up sleeping objects) */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btRigidBody extends btCollisionObject { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBody(Pointer p) { super(p); } + + /**The btRigidBodyConstructionInfo structure provides information to create a rigid body. Setting mass to zero creates a fixed (non-dynamic) rigid body. + * For dynamic objects, you can use the collision shape to approximate the local inertia tensor, otherwise use the zero vector (default argument) + * You can use the motion state to synchronize the world transform between physics and graphics objects. + * And if the motion state is provided, the rigid body will initialize its initial world transform from the motion state, + * m_startWorldTransform is only used when you don't provide a motion state. */ + @NoOffset public static class btRigidBodyConstructionInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBodyConstructionInfo(Pointer p) { super(p); } + + public native @Cast("btScalar") float m_mass(); public native btRigidBodyConstructionInfo m_mass(float setter); + + /**When a motionState is provided, the rigid body will initialize its world transform from the motion state + * In this case, m_startWorldTransform is ignored. */ + public native btMotionState m_motionState(); public native btRigidBodyConstructionInfo m_motionState(btMotionState setter); + public native @ByRef btTransform m_startWorldTransform(); public native btRigidBodyConstructionInfo m_startWorldTransform(btTransform setter); + + public native btCollisionShape m_collisionShape(); public native btRigidBodyConstructionInfo m_collisionShape(btCollisionShape setter); + public native @ByRef btVector3 m_localInertia(); public native btRigidBodyConstructionInfo m_localInertia(btVector3 setter); + public native @Cast("btScalar") float m_linearDamping(); public native btRigidBodyConstructionInfo m_linearDamping(float setter); + public native @Cast("btScalar") float m_angularDamping(); public native btRigidBodyConstructionInfo m_angularDamping(float setter); + + /**best simulation results when friction is non-zero */ + public native @Cast("btScalar") float m_friction(); public native btRigidBodyConstructionInfo m_friction(float setter); + /**the m_rollingFriction prevents rounded shapes, such as spheres, cylinders and capsules from rolling forever. + * See Bullet/Demos/RollingFrictionDemo for usage */ + public native @Cast("btScalar") float m_rollingFriction(); public native btRigidBodyConstructionInfo m_rollingFriction(float setter); + public native @Cast("btScalar") float m_spinningFriction(); public native btRigidBodyConstructionInfo m_spinningFriction(float setter); //torsional friction around contact normal + + /**best simulation results using zero restitution. */ + public native @Cast("btScalar") float m_restitution(); public native btRigidBodyConstructionInfo m_restitution(float setter); + + public native @Cast("btScalar") float m_linearSleepingThreshold(); public native btRigidBodyConstructionInfo m_linearSleepingThreshold(float setter); + public native @Cast("btScalar") float m_angularSleepingThreshold(); public native btRigidBodyConstructionInfo m_angularSleepingThreshold(float setter); + + //Additional damping can help avoiding lowpass jitter motion, help stability for ragdolls etc. + //Such damping is undesirable, so once the overall simulation quality of the rigid body dynamics system has improved, this should become obsolete + public native @Cast("bool") boolean m_additionalDamping(); public native btRigidBodyConstructionInfo m_additionalDamping(boolean setter); + public native @Cast("btScalar") float m_additionalDampingFactor(); public native btRigidBodyConstructionInfo m_additionalDampingFactor(float setter); + public native @Cast("btScalar") float m_additionalLinearDampingThresholdSqr(); public native btRigidBodyConstructionInfo m_additionalLinearDampingThresholdSqr(float setter); + public native @Cast("btScalar") float m_additionalAngularDampingThresholdSqr(); public native btRigidBodyConstructionInfo m_additionalAngularDampingThresholdSqr(float setter); + public native @Cast("btScalar") float m_additionalAngularDampingFactor(); public native btRigidBodyConstructionInfo m_additionalAngularDampingFactor(float setter); + + public btRigidBodyConstructionInfo(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia) { super((Pointer)null); allocate(mass, motionState, collisionShape, localInertia); } + private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia); + public btRigidBodyConstructionInfo(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape) { super((Pointer)null); allocate(mass, motionState, collisionShape); } + private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape); + } + + /**btRigidBody constructor using construction info */ + public btRigidBody(@Const @ByRef btRigidBodyConstructionInfo constructionInfo) { super((Pointer)null); allocate(constructionInfo); } + private native void allocate(@Const @ByRef btRigidBodyConstructionInfo constructionInfo); + + /**btRigidBody constructor for backwards compatibility. + * To specify friction (etc) during rigid body construction, please use the other constructor (using btRigidBodyConstructionInfo) */ + public btRigidBody(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia) { super((Pointer)null); allocate(mass, motionState, collisionShape, localInertia); } + private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape, @Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 localInertia); + public btRigidBody(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape) { super((Pointer)null); allocate(mass, motionState, collisionShape); } + private native void allocate(@Cast("btScalar") float mass, btMotionState motionState, btCollisionShape collisionShape); + public native void proceedToTransform(@Const @ByRef btTransform newTrans); + + /**to keep collision detection and dynamics separate we don't store a rigidbody pointer + * but a rigidbody is derived from btCollisionObject, so we can safely perform an upcast */ + public static native @Const btRigidBody upcast(@Const btCollisionObject colObj); + + /** continuous collision detection needs prediction */ + public native void predictIntegratedTransform(@Cast("btScalar") float step, @ByRef btTransform predictedTransform); + + public native void saveKinematicState(@Cast("btScalar") float step); + + public native void applyGravity(); + + public native void clearGravity(); + + public native void setGravity(@Const @ByRef btVector3 acceleration); + + public native @Const @ByRef btVector3 getGravity(); + + public native void setDamping(@Cast("btScalar") float lin_damping, @Cast("btScalar") float ang_damping); + + public native @Cast("btScalar") float getLinearDamping(); + + public native @Cast("btScalar") float getAngularDamping(); + + public native @Cast("btScalar") float getLinearSleepingThreshold(); + + public native @Cast("btScalar") float getAngularSleepingThreshold(); + + public native void applyDamping(@Cast("btScalar") float timeStep); + + public native btCollisionShape getCollisionShape(); + + public native void setMassProps(@Cast("btScalar") float mass, @Const @ByRef btVector3 inertia); + + public native @Const @ByRef btVector3 getLinearFactor(); + public native void setLinearFactor(@Const @ByRef btVector3 linearFactor); + public native @Cast("btScalar") float getInvMass(); + public native @Cast("btScalar") float getMass(); + public native @Const @ByRef btMatrix3x3 getInvInertiaTensorWorld(); + + public native void integrateVelocities(@Cast("btScalar") float step); + + public native void setCenterOfMassTransform(@Const @ByRef btTransform xform); + + public native void applyCentralForce(@Const @ByRef btVector3 force); + + public native @Const @ByRef btVector3 getTotalForce(); + + public native @Const @ByRef btVector3 getTotalTorque(); + + public native @Const @ByRef btVector3 getInvInertiaDiagLocal(); + + public native void setInvInertiaDiagLocal(@Const @ByRef btVector3 diagInvInertia); + + public native void setSleepingThresholds(@Cast("btScalar") float linear, @Cast("btScalar") float angular); + + public native void applyTorque(@Const @ByRef btVector3 torque); + + public native void applyForce(@Const @ByRef btVector3 force, @Const @ByRef btVector3 rel_pos); + + public native void applyCentralImpulse(@Const @ByRef btVector3 impulse); + + public native void applyTorqueImpulse(@Const @ByRef btVector3 torque); + + public native void applyImpulse(@Const @ByRef btVector3 impulse, @Const @ByRef btVector3 rel_pos); + + public native void applyPushImpulse(@Const @ByRef btVector3 impulse, @Const @ByRef btVector3 rel_pos); + + public native @ByVal btVector3 getPushVelocity(); + + public native @ByVal btVector3 getTurnVelocity(); + + public native void setPushVelocity(@Const @ByRef btVector3 v); + +// #if defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0 +// #endif + + public native void setTurnVelocity(@Const @ByRef btVector3 v); + + public native void applyCentralPushImpulse(@Const @ByRef btVector3 impulse); + + public native void applyTorqueTurnImpulse(@Const @ByRef btVector3 torque); + + public native void clearForces(); + + public native void updateInertiaTensor(); + + public native @Const @ByRef btVector3 getCenterOfMassPosition(); + public native @ByVal btQuaternion getOrientation(); + + public native @Const @ByRef btTransform getCenterOfMassTransform(); + public native @Const @ByRef btVector3 getLinearVelocity(); + public native @Const @ByRef btVector3 getAngularVelocity(); + + public native void setLinearVelocity(@Const @ByRef btVector3 lin_vel); + + public native void setAngularVelocity(@Const @ByRef btVector3 ang_vel); + + public native @ByVal btVector3 getVelocityInLocalPoint(@Const @ByRef btVector3 rel_pos); + + public native @ByVal btVector3 getPushVelocityInLocalPoint(@Const @ByRef btVector3 rel_pos); + + public native void translate(@Const @ByRef btVector3 v); + + public native void getAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native @Cast("btScalar") float computeImpulseDenominator(@Const @ByRef btVector3 pos, @Const @ByRef btVector3 normal); + + public native @Cast("btScalar") float computeAngularImpulseDenominator(@Const @ByRef btVector3 axis); + + public native void updateDeactivation(@Cast("btScalar") float timeStep); + + public native @Cast("bool") boolean wantsSleeping(); + public native btBroadphaseProxy getBroadphaseProxy(); + public native void setNewBroadphaseProxy(btBroadphaseProxy broadphaseProxy); + + //btMotionState allows to automatic synchronize the world transform for active objects + public native btMotionState getMotionState(); + public native void setMotionState(btMotionState motionState); + + //for experimental overriding of friction/contact solver func + public native int m_contactSolverType(); public native btRigidBody m_contactSolverType(int setter); + public native int m_frictionSolverType(); public native btRigidBody m_frictionSolverType(int setter); + + public native void setAngularFactor(@Const @ByRef btVector3 angFac); + + public native void setAngularFactor(@Cast("btScalar") float angFac); + public native @Const @ByRef btVector3 getAngularFactor(); + + //is this rigidbody added to a btCollisionWorld/btDynamicsWorld/btBroadphase? + public native @Cast("bool") boolean isInWorld(); + + public native void addConstraintRef(btTypedConstraint c); + public native void removeConstraintRef(btTypedConstraint c); + + public native btTypedConstraint getConstraintRef(int index); + + public native int getNumConstraintRefs(); + + public native void setFlags(int flags); + + public native int getFlags(); + + /**perform implicit force computation in world space */ + public native @ByVal btVector3 computeGyroscopicImpulseImplicit_World(@Cast("btScalar") float dt); + + /**perform implicit force computation in body space (inertial frame) */ + public native @ByVal btVector3 computeGyroscopicImpulseImplicit_Body(@Cast("btScalar") float step); + + /**explicit version is best avoided, it gains energy */ + public native @ByVal btVector3 computeGyroscopicForceExplicit(@Cast("btScalar") float maxGyroscopicForce); + public native @ByVal btVector3 getLocalInertia(); + + /////////////////////////////////////////////// + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native void serializeSingleObject(btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java new file mode 100644 index 00000000000..1b07277a5b8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java @@ -0,0 +1,60 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btRigidBodyDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btRigidBodyDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btRigidBodyDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBodyDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btRigidBodyDoubleData position(long position) { + return (btRigidBodyDoubleData)super.position(position); + } + @Override public btRigidBodyDoubleData getPointer(long i) { + return new btRigidBodyDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionObjectDoubleData m_collisionObjectData(); public native btRigidBodyDoubleData m_collisionObjectData(btCollisionObjectDoubleData setter); + public native @ByRef btMatrix3x3DoubleData m_invInertiaTensorWorld(); public native btRigidBodyDoubleData m_invInertiaTensorWorld(btMatrix3x3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearVelocity(); public native btRigidBodyDoubleData m_linearVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularVelocity(); public native btRigidBodyDoubleData m_angularVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_angularFactor(); public native btRigidBodyDoubleData m_angularFactor(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_linearFactor(); public native btRigidBodyDoubleData m_linearFactor(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_gravity(); public native btRigidBodyDoubleData m_gravity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_gravity_acceleration(); public native btRigidBodyDoubleData m_gravity_acceleration(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_invInertiaLocal(); public native btRigidBodyDoubleData m_invInertiaLocal(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_totalForce(); public native btRigidBodyDoubleData m_totalForce(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_totalTorque(); public native btRigidBodyDoubleData m_totalTorque(btVector3DoubleData setter); + public native double m_inverseMass(); public native btRigidBodyDoubleData m_inverseMass(double setter); + public native double m_linearDamping(); public native btRigidBodyDoubleData m_linearDamping(double setter); + public native double m_angularDamping(); public native btRigidBodyDoubleData m_angularDamping(double setter); + public native double m_additionalDampingFactor(); public native btRigidBodyDoubleData m_additionalDampingFactor(double setter); + public native double m_additionalLinearDampingThresholdSqr(); public native btRigidBodyDoubleData m_additionalLinearDampingThresholdSqr(double setter); + public native double m_additionalAngularDampingThresholdSqr(); public native btRigidBodyDoubleData m_additionalAngularDampingThresholdSqr(double setter); + public native double m_additionalAngularDampingFactor(); public native btRigidBodyDoubleData m_additionalAngularDampingFactor(double setter); + public native double m_linearSleepingThreshold(); public native btRigidBodyDoubleData m_linearSleepingThreshold(double setter); + public native double m_angularSleepingThreshold(); public native btRigidBodyDoubleData m_angularSleepingThreshold(double setter); + public native int m_additionalDamping(); public native btRigidBodyDoubleData m_additionalDamping(int setter); + public native @Cast("char") byte m_padding(int i); public native btRigidBodyDoubleData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java new file mode 100644 index 00000000000..9dc5754dad3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +//@todo add m_optionalMotionState and m_constraintRefs to btRigidBodyData +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btRigidBodyFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btRigidBodyFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btRigidBodyFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRigidBodyFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btRigidBodyFloatData position(long position) { + return (btRigidBodyFloatData)super.position(position); + } + @Override public btRigidBodyFloatData getPointer(long i) { + return new btRigidBodyFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionObjectFloatData m_collisionObjectData(); public native btRigidBodyFloatData m_collisionObjectData(btCollisionObjectFloatData setter); + public native @ByRef btMatrix3x3FloatData m_invInertiaTensorWorld(); public native btRigidBodyFloatData m_invInertiaTensorWorld(btMatrix3x3FloatData setter); + public native @ByRef btVector3FloatData m_linearVelocity(); public native btRigidBodyFloatData m_linearVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularVelocity(); public native btRigidBodyFloatData m_angularVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_angularFactor(); public native btRigidBodyFloatData m_angularFactor(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_linearFactor(); public native btRigidBodyFloatData m_linearFactor(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_gravity(); public native btRigidBodyFloatData m_gravity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_gravity_acceleration(); public native btRigidBodyFloatData m_gravity_acceleration(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_invInertiaLocal(); public native btRigidBodyFloatData m_invInertiaLocal(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_totalForce(); public native btRigidBodyFloatData m_totalForce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_totalTorque(); public native btRigidBodyFloatData m_totalTorque(btVector3FloatData setter); + public native float m_inverseMass(); public native btRigidBodyFloatData m_inverseMass(float setter); + public native float m_linearDamping(); public native btRigidBodyFloatData m_linearDamping(float setter); + public native float m_angularDamping(); public native btRigidBodyFloatData m_angularDamping(float setter); + public native float m_additionalDampingFactor(); public native btRigidBodyFloatData m_additionalDampingFactor(float setter); + public native float m_additionalLinearDampingThresholdSqr(); public native btRigidBodyFloatData m_additionalLinearDampingThresholdSqr(float setter); + public native float m_additionalAngularDampingThresholdSqr(); public native btRigidBodyFloatData m_additionalAngularDampingThresholdSqr(float setter); + public native float m_additionalAngularDampingFactor(); public native btRigidBodyFloatData m_additionalAngularDampingFactor(float setter); + public native float m_linearSleepingThreshold(); public native btRigidBodyFloatData m_linearSleepingThreshold(float setter); + public native float m_angularSleepingThreshold(); public native btRigidBodyFloatData m_angularSleepingThreshold(float setter); + public native int m_additionalDamping(); public native btRigidBodyFloatData m_additionalDamping(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java new file mode 100644 index 00000000000..ff0bdda07a6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif //BT_USE_DOUBLE_PRECISION + +/** Rotation Limit structure for generic joints */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btRotationalLimitMotor extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRotationalLimitMotor(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btRotationalLimitMotor(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btRotationalLimitMotor position(long position) { + return (btRotationalLimitMotor)super.position(position); + } + @Override public btRotationalLimitMotor getPointer(long i) { + return new btRotationalLimitMotor((Pointer)this).offsetAddress(i); + } + + /** limit_parameters + * \{ */ + /** joint limit */ + public native @Cast("btScalar") float m_loLimit(); public native btRotationalLimitMotor m_loLimit(float setter); + /** joint limit */ + public native @Cast("btScalar") float m_hiLimit(); public native btRotationalLimitMotor m_hiLimit(float setter); + /** target motor velocity */ + public native @Cast("btScalar") float m_targetVelocity(); public native btRotationalLimitMotor m_targetVelocity(float setter); + /** max force on motor */ + public native @Cast("btScalar") float m_maxMotorForce(); public native btRotationalLimitMotor m_maxMotorForce(float setter); + /** max force on limit */ + public native @Cast("btScalar") float m_maxLimitForce(); public native btRotationalLimitMotor m_maxLimitForce(float setter); + /** Damping. */ + public native @Cast("btScalar") float m_damping(); public native btRotationalLimitMotor m_damping(float setter); + public native @Cast("btScalar") float m_limitSoftness(); public native btRotationalLimitMotor m_limitSoftness(float setter); /** Relaxation factor */ + /** Constraint force mixing factor */ + public native @Cast("btScalar") float m_normalCFM(); public native btRotationalLimitMotor m_normalCFM(float setter); + /** Error tolerance factor when joint is at limit */ + public native @Cast("btScalar") float m_stopERP(); public native btRotationalLimitMotor m_stopERP(float setter); + /** Constraint force mixing factor when joint is at limit */ + public native @Cast("btScalar") float m_stopCFM(); public native btRotationalLimitMotor m_stopCFM(float setter); + /** restitution factor */ + public native @Cast("btScalar") float m_bounce(); public native btRotationalLimitMotor m_bounce(float setter); + public native @Cast("bool") boolean m_enableMotor(); public native btRotationalLimitMotor m_enableMotor(boolean setter); + + /**\} +

+ * temp_variables + * \{ */ + public native @Cast("btScalar") float m_currentLimitError(); public native btRotationalLimitMotor m_currentLimitError(float setter); /** How much is violated this limit */ + public native @Cast("btScalar") float m_currentPosition(); public native btRotationalLimitMotor m_currentPosition(float setter); /** current value of angle */ + /** 0=free, 1=at lo limit, 2=at hi limit */ + public native int m_currentLimit(); public native btRotationalLimitMotor m_currentLimit(int setter); + public native @Cast("btScalar") float m_accumulatedImpulse(); public native btRotationalLimitMotor m_accumulatedImpulse(float setter); + /**\} */ + + public btRotationalLimitMotor() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btRotationalLimitMotor(@Const @ByRef btRotationalLimitMotor limot) { super((Pointer)null); allocate(limot); } + private native void allocate(@Const @ByRef btRotationalLimitMotor limot); + + /** Is limited */ + public native @Cast("bool") boolean isLimited(); + + /** Need apply correction */ + public native @Cast("bool") boolean needApplyTorques(); + + /** calculates error + /** + calculates m_currentLimit and m_currentLimitError. + */ + public native int testLimitValue(@Cast("btScalar") float test_value); + + /** apply the correction impulses for two bodies */ + public native @Cast("btScalar") float solveAngularLimits(@Cast("btScalar") float timeStep, @ByRef btVector3 axis, @Cast("btScalar") float jacDiagABInv, btRigidBody body0, btRigidBody body1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java new file mode 100644 index 00000000000..3920f8b8137 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java @@ -0,0 +1,69 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btRotationalLimitMotor2 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btRotationalLimitMotor2(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btRotationalLimitMotor2(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btRotationalLimitMotor2 position(long position) { + return (btRotationalLimitMotor2)super.position(position); + } + @Override public btRotationalLimitMotor2 getPointer(long i) { + return new btRotationalLimitMotor2((Pointer)this).offsetAddress(i); + } + + // upper < lower means free + // upper == lower means locked + // upper > lower means limited + public native @Cast("btScalar") float m_loLimit(); public native btRotationalLimitMotor2 m_loLimit(float setter); + public native @Cast("btScalar") float m_hiLimit(); public native btRotationalLimitMotor2 m_hiLimit(float setter); + public native @Cast("btScalar") float m_bounce(); public native btRotationalLimitMotor2 m_bounce(float setter); + public native @Cast("btScalar") float m_stopERP(); public native btRotationalLimitMotor2 m_stopERP(float setter); + public native @Cast("btScalar") float m_stopCFM(); public native btRotationalLimitMotor2 m_stopCFM(float setter); + public native @Cast("btScalar") float m_motorERP(); public native btRotationalLimitMotor2 m_motorERP(float setter); + public native @Cast("btScalar") float m_motorCFM(); public native btRotationalLimitMotor2 m_motorCFM(float setter); + public native @Cast("bool") boolean m_enableMotor(); public native btRotationalLimitMotor2 m_enableMotor(boolean setter); + public native @Cast("btScalar") float m_targetVelocity(); public native btRotationalLimitMotor2 m_targetVelocity(float setter); + public native @Cast("btScalar") float m_maxMotorForce(); public native btRotationalLimitMotor2 m_maxMotorForce(float setter); + public native @Cast("bool") boolean m_servoMotor(); public native btRotationalLimitMotor2 m_servoMotor(boolean setter); + public native @Cast("btScalar") float m_servoTarget(); public native btRotationalLimitMotor2 m_servoTarget(float setter); + public native @Cast("bool") boolean m_enableSpring(); public native btRotationalLimitMotor2 m_enableSpring(boolean setter); + public native @Cast("btScalar") float m_springStiffness(); public native btRotationalLimitMotor2 m_springStiffness(float setter); + public native @Cast("bool") boolean m_springStiffnessLimited(); public native btRotationalLimitMotor2 m_springStiffnessLimited(boolean setter); + public native @Cast("btScalar") float m_springDamping(); public native btRotationalLimitMotor2 m_springDamping(float setter); + public native @Cast("bool") boolean m_springDampingLimited(); public native btRotationalLimitMotor2 m_springDampingLimited(boolean setter); + public native @Cast("btScalar") float m_equilibriumPoint(); public native btRotationalLimitMotor2 m_equilibriumPoint(float setter); + + public native @Cast("btScalar") float m_currentLimitError(); public native btRotationalLimitMotor2 m_currentLimitError(float setter); + public native @Cast("btScalar") float m_currentLimitErrorHi(); public native btRotationalLimitMotor2 m_currentLimitErrorHi(float setter); + public native @Cast("btScalar") float m_currentPosition(); public native btRotationalLimitMotor2 m_currentPosition(float setter); + public native int m_currentLimit(); public native btRotationalLimitMotor2 m_currentLimit(int setter); + + public btRotationalLimitMotor2() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btRotationalLimitMotor2(@Const @ByRef btRotationalLimitMotor2 limot) { super((Pointer)null); allocate(limot); } + private native void allocate(@Const @ByRef btRotationalLimitMotor2 limot); + + public native @Cast("bool") boolean isLimited(); + + public native void testLimitValue(@Cast("btScalar") float test_value); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java new file mode 100644 index 00000000000..5c7931e8927 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**The btSequentialImpulseConstraintSolver is a fast SIMD implementation of the Projected Gauss Seidel (iterative LCP) method. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSequentialImpulseConstraintSolver extends btConstraintSolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSequentialImpulseConstraintSolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSequentialImpulseConstraintSolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSequentialImpulseConstraintSolver position(long position) { + return (btSequentialImpulseConstraintSolver)super.position(position); + } + @Override public btSequentialImpulseConstraintSolver getPointer(long i) { + return new btSequentialImpulseConstraintSolver((Pointer)this).offsetAddress(i); + } + + + public btSequentialImpulseConstraintSolver() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("btScalar") float solveGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + public native @Cast("btScalar") float solveGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + + /**clear internal cached data and reset random seed */ + public native void reset(); + + public native @Cast("unsigned long") long btRand2(); + + public native int btRandInt2(int n); + + public native void setRandSeed(@Cast("unsigned long") long seed); + public native @Cast("unsigned long") long getRandSeed(); + + public native @Cast("btConstraintSolverType") int getSolverType(); + + + + /**Various implementations of solving a single constraint row using a generic equality constraint, using scalar reference, SSE2 or SSE4 */ + + /**Various implementations of solving a single constraint row using an inequality (lower limit) constraint, using scalar reference, SSE2 or SSE4 */ + public native @ByRef btSolverAnalyticsData m_analyticsData(); public native btSequentialImpulseConstraintSolver m_analyticsData(btSolverAnalyticsData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java new file mode 100644 index 00000000000..a58a6e3a062 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**The btSimpleDynamicsWorld serves as unit-test and to verify more complicated and optimized dynamics worlds. + * Please use btDiscreteDynamicsWorld instead */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSimpleDynamicsWorld extends btDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimpleDynamicsWorld(Pointer p) { super(p); } + + /**this btSimpleDynamicsWorld constructor creates dispatcher, broadphase pairCache and constraintSolver */ + public btSimpleDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); + + /**maxSubSteps/fixedTimeStep for interpolation is currently ignored for btSimpleDynamicsWorld, use btDiscreteDynamicsWorld instead */ + public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); + public native int stepSimulation(@Cast("btScalar") float timeStep); + + public native void setGravity(@Const @ByRef btVector3 gravity); + + public native @ByVal btVector3 getGravity(); + + public native void addRigidBody(btRigidBody body); + + public native void addRigidBody(btRigidBody body, int group, int mask); + + public native void removeRigidBody(btRigidBody body); + + public native void debugDrawWorld(); + + public native void addAction(btActionInterface action); + + public native void removeAction(btActionInterface action); + + /**removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btCollisionWorld::removeCollisionObject */ + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native void updateAabbs(); + + public native void synchronizeMotionStates(); + + public native void setConstraintSolver(btConstraintSolver solver); + + public native btConstraintSolver getConstraintSolver(); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + public native void clearForces(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManager.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManager.java new file mode 100644 index 00000000000..dec071e1f3c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManager.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSimulationIslandManager extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSimulationIslandManager() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimulationIslandManager(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java new file mode 100644 index 00000000000..fb074bc3688 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java @@ -0,0 +1,133 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSliderConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSliderConstraint(Pointer p) { super(p); } + + + // constructors + public btSliderConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btTransform frameInA, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); + public btSliderConstraint(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA) { super((Pointer)null); allocate(rbB, frameInB, useLinearReferenceFrameA); } + private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB, @Cast("bool") boolean useLinearReferenceFrameA); + + // overrides + + // access + public native @Const @ByRef btRigidBody getRigidBodyA(); + public native @Const @ByRef btRigidBody getRigidBodyB(); + public native @Const @ByRef btTransform getCalculatedTransformA(); + public native @Const @ByRef btTransform getCalculatedTransformB(); + public native @ByRef btTransform getFrameOffsetA(); + public native @ByRef btTransform getFrameOffsetB(); + public native @Cast("btScalar") float getLowerLinLimit(); + public native void setLowerLinLimit(@Cast("btScalar") float lowerLimit); + public native @Cast("btScalar") float getUpperLinLimit(); + public native void setUpperLinLimit(@Cast("btScalar") float upperLimit); + public native @Cast("btScalar") float getLowerAngLimit(); + public native void setLowerAngLimit(@Cast("btScalar") float lowerLimit); + public native @Cast("btScalar") float getUpperAngLimit(); + public native void setUpperAngLimit(@Cast("btScalar") float upperLimit); + public native @Cast("bool") boolean getUseLinearReferenceFrameA(); + public native @Cast("btScalar") float getSoftnessDirLin(); + public native @Cast("btScalar") float getRestitutionDirLin(); + public native @Cast("btScalar") float getDampingDirLin(); + public native @Cast("btScalar") float getSoftnessDirAng(); + public native @Cast("btScalar") float getRestitutionDirAng(); + public native @Cast("btScalar") float getDampingDirAng(); + public native @Cast("btScalar") float getSoftnessLimLin(); + public native @Cast("btScalar") float getRestitutionLimLin(); + public native @Cast("btScalar") float getDampingLimLin(); + public native @Cast("btScalar") float getSoftnessLimAng(); + public native @Cast("btScalar") float getRestitutionLimAng(); + public native @Cast("btScalar") float getDampingLimAng(); + public native @Cast("btScalar") float getSoftnessOrthoLin(); + public native @Cast("btScalar") float getRestitutionOrthoLin(); + public native @Cast("btScalar") float getDampingOrthoLin(); + public native @Cast("btScalar") float getSoftnessOrthoAng(); + public native @Cast("btScalar") float getRestitutionOrthoAng(); + public native @Cast("btScalar") float getDampingOrthoAng(); + public native void setSoftnessDirLin(@Cast("btScalar") float softnessDirLin); + public native void setRestitutionDirLin(@Cast("btScalar") float restitutionDirLin); + public native void setDampingDirLin(@Cast("btScalar") float dampingDirLin); + public native void setSoftnessDirAng(@Cast("btScalar") float softnessDirAng); + public native void setRestitutionDirAng(@Cast("btScalar") float restitutionDirAng); + public native void setDampingDirAng(@Cast("btScalar") float dampingDirAng); + public native void setSoftnessLimLin(@Cast("btScalar") float softnessLimLin); + public native void setRestitutionLimLin(@Cast("btScalar") float restitutionLimLin); + public native void setDampingLimLin(@Cast("btScalar") float dampingLimLin); + public native void setSoftnessLimAng(@Cast("btScalar") float softnessLimAng); + public native void setRestitutionLimAng(@Cast("btScalar") float restitutionLimAng); + public native void setDampingLimAng(@Cast("btScalar") float dampingLimAng); + public native void setSoftnessOrthoLin(@Cast("btScalar") float softnessOrthoLin); + public native void setRestitutionOrthoLin(@Cast("btScalar") float restitutionOrthoLin); + public native void setDampingOrthoLin(@Cast("btScalar") float dampingOrthoLin); + public native void setSoftnessOrthoAng(@Cast("btScalar") float softnessOrthoAng); + public native void setRestitutionOrthoAng(@Cast("btScalar") float restitutionOrthoAng); + public native void setDampingOrthoAng(@Cast("btScalar") float dampingOrthoAng); + public native void setPoweredLinMotor(@Cast("bool") boolean onOff); + public native @Cast("bool") boolean getPoweredLinMotor(); + public native void setTargetLinMotorVelocity(@Cast("btScalar") float targetLinMotorVelocity); + public native @Cast("btScalar") float getTargetLinMotorVelocity(); + public native void setMaxLinMotorForce(@Cast("btScalar") float maxLinMotorForce); + public native @Cast("btScalar") float getMaxLinMotorForce(); + public native void setPoweredAngMotor(@Cast("bool") boolean onOff); + public native @Cast("bool") boolean getPoweredAngMotor(); + public native void setTargetAngMotorVelocity(@Cast("btScalar") float targetAngMotorVelocity); + public native @Cast("btScalar") float getTargetAngMotorVelocity(); + public native void setMaxAngMotorForce(@Cast("btScalar") float maxAngMotorForce); + public native @Cast("btScalar") float getMaxAngMotorForce(); + + public native @Cast("btScalar") float getLinearPos(); + public native @Cast("btScalar") float getAngularPos(); + + // access for ODE solver + public native @Cast("bool") boolean getSolveLinLimit(); + public native @Cast("btScalar") float getLinDepth(); + public native @Cast("bool") boolean getSolveAngLimit(); + public native @Cast("btScalar") float getAngDepth(); + // shared code used by ODE solver + public native void calculateTransforms(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + public native void testLinLimits(); + public native void testAngLimits(); + // access for PE Solver + public native @ByVal btVector3 getAncorInA(); + public native @ByVal btVector3 getAncorInB(); + // access for UseFrameOffset + public native @Cast("bool") boolean getUseFrameOffset(); + public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); + + public native void setFrames(@Const @ByRef btTransform frameA, @Const @ByRef btTransform frameB); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int getFlags(); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java new file mode 100644 index 00000000000..aec98f1a647 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSliderConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSliderConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSliderConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSliderConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSliderConstraintData position(long position) { + return (btSliderConstraintData)super.position(position); + } + @Override public btSliderConstraintData getPointer(long i) { + return new btSliderConstraintData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformFloatData m_rbAFrame(); public native btSliderConstraintData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformFloatData m_rbBFrame(); public native btSliderConstraintData m_rbBFrame(btTransformFloatData setter); + + public native float m_linearUpperLimit(); public native btSliderConstraintData m_linearUpperLimit(float setter); + public native float m_linearLowerLimit(); public native btSliderConstraintData m_linearLowerLimit(float setter); + + public native float m_angularUpperLimit(); public native btSliderConstraintData m_angularUpperLimit(float setter); + public native float m_angularLowerLimit(); public native btSliderConstraintData m_angularLowerLimit(float setter); + + public native int m_useLinearReferenceFrameA(); public native btSliderConstraintData m_useLinearReferenceFrameA(int setter); + public native int m_useOffsetForConstraintFrame(); public native btSliderConstraintData m_useOffsetForConstraintFrame(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java new file mode 100644 index 00000000000..c99c43e7eb9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSliderConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSliderConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSliderConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSliderConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSliderConstraintDoubleData position(long position) { + return (btSliderConstraintDoubleData)super.position(position); + } + @Override public btSliderConstraintDoubleData getPointer(long i) { + return new btSliderConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btTransformDoubleData m_rbAFrame(); public native btSliderConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. + public native @ByRef btTransformDoubleData m_rbBFrame(); public native btSliderConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); + + public native double m_linearUpperLimit(); public native btSliderConstraintDoubleData m_linearUpperLimit(double setter); + public native double m_linearLowerLimit(); public native btSliderConstraintDoubleData m_linearLowerLimit(double setter); + + public native double m_angularUpperLimit(); public native btSliderConstraintDoubleData m_angularUpperLimit(double setter); + public native double m_angularLowerLimit(); public native btSliderConstraintDoubleData m_angularLowerLimit(double setter); + + public native int m_useLinearReferenceFrameA(); public native btSliderConstraintDoubleData m_useLinearReferenceFrameA(int setter); + public native int m_useOffsetForConstraintFrame(); public native btSliderConstraintDoubleData m_useOffsetForConstraintFrame(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java new file mode 100644 index 00000000000..c132189f24b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolverAnalyticsData extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverAnalyticsData(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSolverAnalyticsData(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSolverAnalyticsData position(long position) { + return (btSolverAnalyticsData)super.position(position); + } + @Override public btSolverAnalyticsData getPointer(long i) { + return new btSolverAnalyticsData((Pointer)this).offsetAddress(i); + } + + public btSolverAnalyticsData() { super((Pointer)null); allocate(); } + private native void allocate(); + public native int m_islandId(); public native btSolverAnalyticsData m_islandId(int setter); + public native int m_numBodies(); public native btSolverAnalyticsData m_numBodies(int setter); + public native int m_numContactManifolds(); public native btSolverAnalyticsData m_numContactManifolds(int setter); + public native int m_numSolverCalls(); public native btSolverAnalyticsData m_numSolverCalls(int setter); + public native int m_numIterationsUsed(); public native btSolverAnalyticsData m_numIterationsUsed(int setter); + public native double m_remainingLeastSquaresResidual(); public native btSolverAnalyticsData m_remainingLeastSquaresResidual(double setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btStackAlloc.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btStackAlloc.java new file mode 100644 index 00000000000..db24874b2ba --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btStackAlloc.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btStackAlloc extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btStackAlloc() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStackAlloc(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor.java new file mode 100644 index 00000000000..b05c61be3d4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor.java @@ -0,0 +1,89 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btTranslationalLimitMotor extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTranslationalLimitMotor(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTranslationalLimitMotor(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTranslationalLimitMotor position(long position) { + return (btTranslationalLimitMotor)super.position(position); + } + @Override public btTranslationalLimitMotor getPointer(long i) { + return new btTranslationalLimitMotor((Pointer)this).offsetAddress(i); + } + + /** the constraint lower limits */ + public native @ByRef btVector3 m_lowerLimit(); public native btTranslationalLimitMotor m_lowerLimit(btVector3 setter); + /** the constraint upper limits */ + public native @ByRef btVector3 m_upperLimit(); public native btTranslationalLimitMotor m_upperLimit(btVector3 setter); + public native @ByRef btVector3 m_accumulatedImpulse(); public native btTranslationalLimitMotor m_accumulatedImpulse(btVector3 setter); + /** Linear_Limit_parameters + * \{ */ + /** Softness for linear limit */ + public native @Cast("btScalar") float m_limitSoftness(); public native btTranslationalLimitMotor m_limitSoftness(float setter); + /** Damping for linear limit */ + public native @Cast("btScalar") float m_damping(); public native btTranslationalLimitMotor m_damping(float setter); + public native @Cast("btScalar") float m_restitution(); public native btTranslationalLimitMotor m_restitution(float setter); /** Bounce parameter for linear limit */ + /** Constraint force mixing factor */ + public native @ByRef btVector3 m_normalCFM(); public native btTranslationalLimitMotor m_normalCFM(btVector3 setter); + /** Error tolerance factor when joint is at limit */ + public native @ByRef btVector3 m_stopERP(); public native btTranslationalLimitMotor m_stopERP(btVector3 setter); + /** Constraint force mixing factor when joint is at limit */ + public native @ByRef btVector3 m_stopCFM(); public native btTranslationalLimitMotor m_stopCFM(btVector3 setter); + /**\} */ + public native @Cast("bool") boolean m_enableMotor(int i); public native btTranslationalLimitMotor m_enableMotor(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_enableMotor(); + /** target motor velocity */ + public native @ByRef btVector3 m_targetVelocity(); public native btTranslationalLimitMotor m_targetVelocity(btVector3 setter); + /** max force on motor */ + public native @ByRef btVector3 m_maxMotorForce(); public native btTranslationalLimitMotor m_maxMotorForce(btVector3 setter); + public native @ByRef btVector3 m_currentLimitError(); public native btTranslationalLimitMotor m_currentLimitError(btVector3 setter); /** How much is violated this limit */ + public native @ByRef btVector3 m_currentLinearDiff(); public native btTranslationalLimitMotor m_currentLinearDiff(btVector3 setter); /** Current relative offset of constraint frames */ + /** 0=free, 1=at lower limit, 2=at upper limit */ + public native int m_currentLimit(int i); public native btTranslationalLimitMotor m_currentLimit(int i, int setter); + @MemberGetter public native IntPointer m_currentLimit(); + + public btTranslationalLimitMotor() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btTranslationalLimitMotor(@Const @ByRef btTranslationalLimitMotor other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btTranslationalLimitMotor other); + + /** Test limit + /** + - free means upper < lower, + - locked means upper == lower + - limited means upper > lower + - limitIndex: first 3 are linear, next 3 are angular + */ + public native @Cast("bool") boolean isLimited(int limitIndex); + public native @Cast("bool") boolean needApplyForce(int limitIndex); + public native int testLimitValue(int limitIndex, @Cast("btScalar") float test_value); + + public native @Cast("btScalar") float solveLinearAxis( + @Cast("btScalar") float timeStep, + @Cast("btScalar") float jacDiagABInv, + @ByRef btRigidBody body1, @Const @ByRef btVector3 pointInA, + @ByRef btRigidBody body2, @Const @ByRef btVector3 pointInB, + int limit_index, + @Const @ByRef btVector3 axis_normal_on_a, + @Const @ByRef btVector3 anchorPos); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor2.java new file mode 100644 index 00000000000..e0477ded9bf --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor2.java @@ -0,0 +1,75 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btTranslationalLimitMotor2 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTranslationalLimitMotor2(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTranslationalLimitMotor2(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTranslationalLimitMotor2 position(long position) { + return (btTranslationalLimitMotor2)super.position(position); + } + @Override public btTranslationalLimitMotor2 getPointer(long i) { + return new btTranslationalLimitMotor2((Pointer)this).offsetAddress(i); + } + + // upper < lower means free + // upper == lower means locked + // upper > lower means limited + public native @ByRef btVector3 m_lowerLimit(); public native btTranslationalLimitMotor2 m_lowerLimit(btVector3 setter); + public native @ByRef btVector3 m_upperLimit(); public native btTranslationalLimitMotor2 m_upperLimit(btVector3 setter); + public native @ByRef btVector3 m_bounce(); public native btTranslationalLimitMotor2 m_bounce(btVector3 setter); + public native @ByRef btVector3 m_stopERP(); public native btTranslationalLimitMotor2 m_stopERP(btVector3 setter); + public native @ByRef btVector3 m_stopCFM(); public native btTranslationalLimitMotor2 m_stopCFM(btVector3 setter); + public native @ByRef btVector3 m_motorERP(); public native btTranslationalLimitMotor2 m_motorERP(btVector3 setter); + public native @ByRef btVector3 m_motorCFM(); public native btTranslationalLimitMotor2 m_motorCFM(btVector3 setter); + public native @Cast("bool") boolean m_enableMotor(int i); public native btTranslationalLimitMotor2 m_enableMotor(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_enableMotor(); + public native @Cast("bool") boolean m_servoMotor(int i); public native btTranslationalLimitMotor2 m_servoMotor(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_servoMotor(); + public native @Cast("bool") boolean m_enableSpring(int i); public native btTranslationalLimitMotor2 m_enableSpring(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_enableSpring(); + public native @ByRef btVector3 m_servoTarget(); public native btTranslationalLimitMotor2 m_servoTarget(btVector3 setter); + public native @ByRef btVector3 m_springStiffness(); public native btTranslationalLimitMotor2 m_springStiffness(btVector3 setter); + public native @Cast("bool") boolean m_springStiffnessLimited(int i); public native btTranslationalLimitMotor2 m_springStiffnessLimited(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_springStiffnessLimited(); + public native @ByRef btVector3 m_springDamping(); public native btTranslationalLimitMotor2 m_springDamping(btVector3 setter); + public native @Cast("bool") boolean m_springDampingLimited(int i); public native btTranslationalLimitMotor2 m_springDampingLimited(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_springDampingLimited(); + public native @ByRef btVector3 m_equilibriumPoint(); public native btTranslationalLimitMotor2 m_equilibriumPoint(btVector3 setter); + public native @ByRef btVector3 m_targetVelocity(); public native btTranslationalLimitMotor2 m_targetVelocity(btVector3 setter); + public native @ByRef btVector3 m_maxMotorForce(); public native btTranslationalLimitMotor2 m_maxMotorForce(btVector3 setter); + + public native @ByRef btVector3 m_currentLimitError(); public native btTranslationalLimitMotor2 m_currentLimitError(btVector3 setter); + public native @ByRef btVector3 m_currentLimitErrorHi(); public native btTranslationalLimitMotor2 m_currentLimitErrorHi(btVector3 setter); + public native @ByRef btVector3 m_currentLinearDiff(); public native btTranslationalLimitMotor2 m_currentLinearDiff(btVector3 setter); + public native int m_currentLimit(int i); public native btTranslationalLimitMotor2 m_currentLimit(int i, int setter); + @MemberGetter public native IntPointer m_currentLimit(); + + public btTranslationalLimitMotor2() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btTranslationalLimitMotor2(@Const @ByRef btTranslationalLimitMotor2 other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btTranslationalLimitMotor2 other); + + public native @Cast("bool") boolean isLimited(int limitIndex); + + public native void testLimitValue(int limitIndex, @Cast("btScalar") float test_value); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java new file mode 100644 index 00000000000..f0f27ff083a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btTypedConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btTypedConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTypedConstraint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btUniversalConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btUniversalConstraint.java new file mode 100644 index 00000000000..67befce5296 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btUniversalConstraint.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** Constraint similar to ODE Universal Joint + * has 2 rotatioonal degrees of freedom, similar to Euler rotations around Z (axis 1) + * and Y (axis 2) + * Description from ODE manual : + * "Given axis 1 on body 1, and axis 2 on body 2 that is perpendicular to axis 1, it keeps them perpendicular. + * In other words, rotation of the two bodies about the direction perpendicular to the two axes will be equal." */ + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btUniversalConstraint extends btGeneric6DofConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btUniversalConstraint(Pointer p) { super(p); } + + + // constructor + // anchor, axis1 and axis2 are in world coordinate system + // axis1 must be orthogonal to axis2 + public btUniversalConstraint(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 anchor, @Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2) { super((Pointer)null); allocate(rbA, rbB, anchor, axis1, axis2); } + private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 anchor, @Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + // access + public native @Const @ByRef btVector3 getAnchor(); + public native @Const @ByRef btVector3 getAnchor2(); + public native @Const @ByRef btVector3 getAxis1(); + public native @Const @ByRef btVector3 getAxis2(); + public native @Cast("btScalar") float getAngle1(); + public native @Cast("btScalar") float getAngle2(); + // limits + public native void setUpperLimit(@Cast("btScalar") float ang1max, @Cast("btScalar") float ang2max); + public native void setLowerLimit(@Cast("btScalar") float ang1min, @Cast("btScalar") float ang2min); + + public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java new file mode 100644 index 00000000000..c877bc13fde --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** btVehicleRaycaster is provides interface for between vehicle simulation and raycasting */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btVehicleRaycaster extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVehicleRaycaster(Pointer p) { super(p); } + + @NoOffset public static class btVehicleRaycasterResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVehicleRaycasterResult(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVehicleRaycasterResult(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVehicleRaycasterResult position(long position) { + return (btVehicleRaycasterResult)super.position(position); + } + @Override public btVehicleRaycasterResult getPointer(long i) { + return new btVehicleRaycasterResult((Pointer)this).offsetAddress(i); + } + + public btVehicleRaycasterResult() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @ByRef btVector3 m_hitPointInWorld(); public native btVehicleRaycasterResult m_hitPointInWorld(btVector3 setter); + public native @ByRef btVector3 m_hitNormalInWorld(); public native btVehicleRaycasterResult m_hitNormalInWorld(btVector3 setter); + public native @Cast("btScalar") float m_distFraction(); public native btVehicleRaycasterResult m_distFraction(float setter); + } + + public native Pointer castRay(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @ByRef btVehicleRaycasterResult result); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java new file mode 100644 index 00000000000..073201e13c4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java @@ -0,0 +1,104 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** btWheelInfo contains information per wheel about friction and suspension. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btWheelInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btWheelInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btWheelInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btWheelInfo position(long position) { + return (btWheelInfo)super.position(position); + } + @Override public btWheelInfo getPointer(long i) { + return new btWheelInfo((Pointer)this).offsetAddress(i); + } + + public static class RaycastInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public RaycastInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public RaycastInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RaycastInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public RaycastInfo position(long position) { + return (RaycastInfo)super.position(position); + } + @Override public RaycastInfo getPointer(long i) { + return new RaycastInfo((Pointer)this).offsetAddress(i); + } + + //set by raycaster + public native @ByRef btVector3 m_contactNormalWS(); public native RaycastInfo m_contactNormalWS(btVector3 setter); //contactnormal + public native @ByRef btVector3 m_contactPointWS(); public native RaycastInfo m_contactPointWS(btVector3 setter); //raycast hitpoint + public native @Cast("btScalar") float m_suspensionLength(); public native RaycastInfo m_suspensionLength(float setter); + public native @ByRef btVector3 m_hardPointWS(); public native RaycastInfo m_hardPointWS(btVector3 setter); //raycast starting point + public native @ByRef btVector3 m_wheelDirectionWS(); public native RaycastInfo m_wheelDirectionWS(btVector3 setter); //direction in worldspace + public native @ByRef btVector3 m_wheelAxleWS(); public native RaycastInfo m_wheelAxleWS(btVector3 setter); // axle in worldspace + public native @Cast("bool") boolean m_isInContact(); public native RaycastInfo m_isInContact(boolean setter); + public native Pointer m_groundObject(); public native RaycastInfo m_groundObject(Pointer setter); //could be general void* ptr + } + + public native @ByRef RaycastInfo m_raycastInfo(); public native btWheelInfo m_raycastInfo(RaycastInfo setter); + + public native @ByRef btTransform m_worldTransform(); public native btWheelInfo m_worldTransform(btTransform setter); + + public native @ByRef btVector3 m_chassisConnectionPointCS(); public native btWheelInfo m_chassisConnectionPointCS(btVector3 setter); //const + public native @ByRef btVector3 m_wheelDirectionCS(); public native btWheelInfo m_wheelDirectionCS(btVector3 setter); //const + public native @ByRef btVector3 m_wheelAxleCS(); public native btWheelInfo m_wheelAxleCS(btVector3 setter); // const or modified by steering + public native @Cast("btScalar") float m_suspensionRestLength1(); public native btWheelInfo m_suspensionRestLength1(float setter); //const + public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btWheelInfo m_maxSuspensionTravelCm(float setter); + public native @Cast("btScalar") float getSuspensionRestLength(); + public native @Cast("btScalar") float m_wheelsRadius(); public native btWheelInfo m_wheelsRadius(float setter); //const + public native @Cast("btScalar") float m_suspensionStiffness(); public native btWheelInfo m_suspensionStiffness(float setter); //const + public native @Cast("btScalar") float m_wheelsDampingCompression(); public native btWheelInfo m_wheelsDampingCompression(float setter); //const + public native @Cast("btScalar") float m_wheelsDampingRelaxation(); public native btWheelInfo m_wheelsDampingRelaxation(float setter); //const + public native @Cast("btScalar") float m_frictionSlip(); public native btWheelInfo m_frictionSlip(float setter); + public native @Cast("btScalar") float m_steering(); public native btWheelInfo m_steering(float setter); + public native @Cast("btScalar") float m_rotation(); public native btWheelInfo m_rotation(float setter); + public native @Cast("btScalar") float m_deltaRotation(); public native btWheelInfo m_deltaRotation(float setter); + public native @Cast("btScalar") float m_rollInfluence(); public native btWheelInfo m_rollInfluence(float setter); + public native @Cast("btScalar") float m_maxSuspensionForce(); public native btWheelInfo m_maxSuspensionForce(float setter); + + public native @Cast("btScalar") float m_engineForce(); public native btWheelInfo m_engineForce(float setter); + + public native @Cast("btScalar") float m_brake(); public native btWheelInfo m_brake(float setter); + + public native @Cast("bool") boolean m_bIsFrontWheel(); public native btWheelInfo m_bIsFrontWheel(boolean setter); + + public native Pointer m_clientInfo(); public native btWheelInfo m_clientInfo(Pointer setter); //can be used to store pointer to sync transforms... + + public btWheelInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btWheelInfo(@ByRef btWheelInfoConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@ByRef btWheelInfoConstructionInfo ci); + + public native void updateWheel(@Const @ByRef btRigidBody chassis, @ByRef RaycastInfo raycastInfo); + + public native @Cast("btScalar") float m_clippedInvContactDotSuspension(); public native btWheelInfo m_clippedInvContactDotSuspension(float setter); + public native @Cast("btScalar") float m_suspensionRelativeVelocity(); public native btWheelInfo m_suspensionRelativeVelocity(float setter); + //calculated by suspension + public native @Cast("btScalar") float m_wheelsSuspensionForce(); public native btWheelInfo m_wheelsSuspensionForce(float setter); + public native @Cast("btScalar") float m_skidInfo(); public native btWheelInfo m_skidInfo(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoConstructionInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoConstructionInfo.java new file mode 100644 index 00000000000..5331af21a80 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoConstructionInfo.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btWheelInfoConstructionInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btWheelInfoConstructionInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btWheelInfoConstructionInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btWheelInfoConstructionInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btWheelInfoConstructionInfo position(long position) { + return (btWheelInfoConstructionInfo)super.position(position); + } + @Override public btWheelInfoConstructionInfo getPointer(long i) { + return new btWheelInfoConstructionInfo((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_chassisConnectionCS(); public native btWheelInfoConstructionInfo m_chassisConnectionCS(btVector3 setter); + public native @ByRef btVector3 m_wheelDirectionCS(); public native btWheelInfoConstructionInfo m_wheelDirectionCS(btVector3 setter); + public native @ByRef btVector3 m_wheelAxleCS(); public native btWheelInfoConstructionInfo m_wheelAxleCS(btVector3 setter); + public native @Cast("btScalar") float m_suspensionRestLength(); public native btWheelInfoConstructionInfo m_suspensionRestLength(float setter); + public native @Cast("btScalar") float m_maxSuspensionTravelCm(); public native btWheelInfoConstructionInfo m_maxSuspensionTravelCm(float setter); + public native @Cast("btScalar") float m_wheelRadius(); public native btWheelInfoConstructionInfo m_wheelRadius(float setter); + + public native @Cast("btScalar") float m_suspensionStiffness(); public native btWheelInfoConstructionInfo m_suspensionStiffness(float setter); + public native @Cast("btScalar") float m_wheelsDampingCompression(); public native btWheelInfoConstructionInfo m_wheelsDampingCompression(float setter); + public native @Cast("btScalar") float m_wheelsDampingRelaxation(); public native btWheelInfoConstructionInfo m_wheelsDampingRelaxation(float setter); + public native @Cast("btScalar") float m_frictionSlip(); public native btWheelInfoConstructionInfo m_frictionSlip(float setter); + public native @Cast("btScalar") float m_maxSuspensionForce(); public native btWheelInfoConstructionInfo m_maxSuspensionForce(float setter); + public native @Cast("bool") boolean m_bIsFrontWheel(); public native btWheelInfoConstructionInfo m_bIsFrontWheel(boolean setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath.java deleted file mode 100644 index a7d137164c6..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath.java +++ /dev/null @@ -1,2675 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; - -public class LinearMath extends org.bytedeco.bullet.presets.LinearMath { - static { Loader.load(); } - -// Parsed from LinearMath/btScalar.h - -/* -Copyright (c) 2003-2009 Erwin Coumans http://bullet.googlecode.com - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SCALAR_H -// #define BT_SCALAR_H - -// #ifdef BT_MANAGED_CODE -//Aligned data types not supported in managed code -// #pragma unmanaged -// #endif - -// #include -// #include //size_t for MSVC 6.0 -// #include - -/* SVN $Revision$ on $Date$ from http://bullet.googlecode.com*/ -public static final int BT_BULLET_VERSION = 320; - -public static native int btGetVersion(); - -public static native int btIsDoublePrecision(); - - -// The following macro "BT_NOT_EMPTY_FILE" can be put into a file -// in order suppress the MS Visual C++ Linker warning 4221 -// -// warning LNK4221: no public symbols found; archive member will be inaccessible -// -// This warning occurs on PC and XBOX when a file compiles out completely -// has no externally visible symbols which may be dependant on configuration -// #defines and options. -// -// see more https://stackoverflow.com/questions/1822887/what-is-the-best-way-to-eliminate-ms-visual-c-linker-warning-warning-lnk422 - -// #if defined(_MSC_VER) -// #else -// #define BT_NOT_EMPTY_FILE -// #endif - -// clang and most formatting tools don't support indentation of preprocessor guards, so turn it off -// clang-format off -// #if defined(DEBUG) || defined (_DEBUG) -// #endif - -// #ifdef _WIN32 - -// #else//_WIN32 - -// #if defined (__CELLOS_LV2__) - -// #else//defined (__CELLOS_LV2__) - -// #ifdef USE_LIBSPE2 - - -// #else//USE_LIBSPE2 - //non-windows systems - -// #if (defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION))) - -// #else//__APPLE__ - -// #define SIMD_FORCE_INLINE inline - /**\todo: check out alignment methods for other platforms/compilers - * #define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16))) - * #define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64))) - * #define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128))) */ -// #define ATTRIBUTE_ALIGNED16(a) a -// #define ATTRIBUTE_ALIGNED64(a) a -// #define ATTRIBUTE_ALIGNED128(a) a -// #ifndef assert -// #include -// #endif - -// #if defined(DEBUG) || defined (_DEBUG) -// #else -// #define btAssert(x) -// #endif - - //btFullAssert is optional, slows down a lot -// #define btFullAssert(x) -// #define btLikely(_c) _c -// #define btUnlikely(_c) _c -// #endif //__APPLE__ -// #endif // LIBSPE2 -// #endif //__CELLOS_LV2__ -// #endif//_WIN32 - - -/**The btScalar type abstracts floating point numbers, to easily switch between double and single floating point precision. */ -// #if defined(BT_USE_DOUBLE_PRECISION) -// #else - //keep BT_LARGE_FLOAT*BT_LARGE_FLOAT < FLT_MAX - public static final double BT_LARGE_FLOAT = 1e18f; -// #endif - -// #ifdef BT_USE_SSE -// #endif //BT_USE_SSE - -// #if defined(BT_USE_SSE) -// #else//BT_USE_SSE - -// #ifdef BT_USE_NEON -// #else //BT_USE_NEON - -// #ifndef BT_INFINITY - public static class btInfMaskConverter extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btInfMaskConverter(Pointer p) { super(p); } - - public native float mask(); public native btInfMaskConverter mask(float setter); - public native int intmask(); public native btInfMaskConverter intmask(int setter); - public btInfMaskConverter(int _mask/*=0x7F800000*/) { super((Pointer)null); allocate(_mask); } - private native void allocate(int _mask/*=0x7F800000*/); - public btInfMaskConverter() { super((Pointer)null); allocate(); } - private native void allocate(); - } - public static native @ByRef btInfMaskConverter btInfinityMask(); public static native void btInfinityMask(btInfMaskConverter setter); -// #define BT_INFINITY (btInfinityMask.mask) - public static native int btGetInfinityMask(); -// #endif -// #endif //BT_USE_NEON - -// #endif //BT_USE_SSE - -// #ifdef BT_USE_NEON -// #endif//BT_USE_NEON - -// #define BT_DECLARE_ALIGNED_ALLOCATOR() -// SIMD_FORCE_INLINE void *operator new(size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } -// SIMD_FORCE_INLINE void operator delete(void *ptr) { btAlignedFree(ptr); } -// SIMD_FORCE_INLINE void *operator new(size_t, void *ptr) { return ptr; } -// SIMD_FORCE_INLINE void operator delete(void *, void *) {} -// SIMD_FORCE_INLINE void *operator new[](size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } -// SIMD_FORCE_INLINE void operator delete[](void *ptr) { btAlignedFree(ptr); } -// SIMD_FORCE_INLINE void *operator new[](size_t, void *ptr) { return ptr; } -// SIMD_FORCE_INLINE void operator delete[](void *, void *) {} - -// #if defined(BT_USE_DOUBLE_PRECISION) || defined(BT_FORCE_DOUBLE_FUNCTIONS) - - public static native @Cast("btScalar") float btSqrt(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btFabs(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btCos(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btSin(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btTan(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btAcos(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btAsin(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btAtan(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btAtan2(@Cast("btScalar") float x, @Cast("btScalar") float y); - public static native @Cast("btScalar") float btExp(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btLog(@Cast("btScalar") float x); - public static native @Cast("btScalar") float btPow(@Cast("btScalar") float x, @Cast("btScalar") float y); - public static native @Cast("btScalar") float btFmod(@Cast("btScalar") float x, @Cast("btScalar") float y); - -// #else//BT_USE_DOUBLE_PRECISION - -// #endif//BT_USE_DOUBLE_PRECISION - -public static native @MemberGetter double SIMD_PI(); -public static final double SIMD_PI = SIMD_PI(); -public static native @MemberGetter double SIMD_2_PI(); -public static final double SIMD_2_PI = SIMD_2_PI(); -public static native @MemberGetter double SIMD_HALF_PI(); -public static final double SIMD_HALF_PI = SIMD_HALF_PI(); -public static native @MemberGetter double SIMD_RADS_PER_DEG(); -public static final double SIMD_RADS_PER_DEG = SIMD_RADS_PER_DEG(); -public static native @MemberGetter double SIMD_DEGS_PER_RAD(); -public static final double SIMD_DEGS_PER_RAD = SIMD_DEGS_PER_RAD(); -public static native @MemberGetter double SIMDSQRT12(); -public static final double SIMDSQRT12 = SIMDSQRT12(); -// #define btRecipSqrt(x) ((btScalar)(btScalar(1.0) / btSqrt(btScalar(x)))) /* reciprocal square root */ -// #define btRecip(x) (btScalar(1.0) / btScalar(x)) - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define SIMD_EPSILON FLT_EPSILON -// #define SIMD_INFINITY FLT_MAX - public static final double BT_ONE = 1.0f; - public static final double BT_ZERO = 0.0f; - public static final double BT_TWO = 2.0f; - public static final double BT_HALF = 0.5f; -// #endif - -// clang-format on - -public static native @Cast("btScalar") float btAtan2Fast(@Cast("btScalar") float y, @Cast("btScalar") float x); - -public static native @Cast("bool") boolean btFuzzyZero(@Cast("btScalar") float x); - -public static native @Cast("bool") boolean btEqual(@Cast("btScalar") float a, @Cast("btScalar") float eps); -public static native @Cast("bool") boolean btGreaterEqual(@Cast("btScalar") float a, @Cast("btScalar") float eps); - -public static native int btIsNegative(@Cast("btScalar") float x); - -public static native @Cast("btScalar") float btRadians(@Cast("btScalar") float x); -public static native @Cast("btScalar") float btDegrees(@Cast("btScalar") float x); - -// #define BT_DECLARE_HANDLE(name) -// typedef struct name##__ -// { -// int unused; -// } * name - -// #ifndef btFsel -public static native @Cast("btScalar") float btFsel(@Cast("btScalar") float a, @Cast("btScalar") float b, @Cast("btScalar") float c); -// #endif -// #define btFsels(a, b, c) (btScalar) btFsel(a, b, c) - -public static native @Cast("bool") boolean btMachineIsLittleEndian(); - -/**btSelect avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360 - * Thanks Phil Knight. See also http://www.cellperformance.com/articles/2006/04/more_techniques_for_eliminatin_1.html */ -public static native @Cast("unsigned") int btSelect(@Cast("unsigned") int condition, @Cast("unsigned") int valueIfConditionNonZero, @Cast("unsigned") int valueIfConditionZero); -public static native float btSelect(@Cast("unsigned") int condition, float valueIfConditionNonZero, float valueIfConditionZero); - -//PCK: endian swapping functions -public static native @Cast("unsigned") int btSwapEndian(@Cast("unsigned") int val); - -public static native @Cast("unsigned short") short btSwapEndian(@Cast("unsigned short") short val); - -/**btSwapFloat uses using char pointers to swap the endianness -////btSwapFloat/btSwapDouble will NOT return a float, because the machine might 'correct' invalid floating point values - * Not all values of sign/exponent/mantissa are valid floating point numbers according to IEEE 754. - * When a floating point unit is faced with an invalid value, it may actually change the value, or worse, throw an exception. - * In most systems, running user mode code, you wouldn't get an exception, but instead the hardware/os/runtime will 'fix' the number for you. - * so instead of returning a float/double, we return integer/long long integer */ -public static native @Cast("unsigned int") int btSwapEndianFloat(float d); - -// unswap using char pointers -public static native float btUnswapEndianFloat(@Cast("unsigned int") int a); - -// swap using char pointers -public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") BytePointer dst); -public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") ByteBuffer dst); -public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") byte[] dst); - -// unswap using char pointers -public static native double btUnswapEndianDouble(@Cast("const unsigned char*") BytePointer src); -public static native double btUnswapEndianDouble(@Cast("const unsigned char*") ByteBuffer src); -public static native double btUnswapEndianDouble(@Cast("const unsigned char*") byte[] src); - -public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") FloatPointer a, @Cast("const btScalar*") FloatPointer b, int n); -public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") FloatBuffer a, @Cast("const btScalar*") FloatBuffer b, int n); -public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") float[] a, @Cast("const btScalar*") float[] b, int n); - -// returns normalized value in range [-SIMD_PI, SIMD_PI] -public static native @Cast("btScalar") float btNormalizeAngle(@Cast("btScalar") float angleInRadians); - -/**rudimentary class to provide type info */ -@NoOffset public static class btTypedObject extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTypedObject(Pointer p) { super(p); } - - public btTypedObject(int objectType) { super((Pointer)null); allocate(objectType); } - private native void allocate(int objectType); - public native int m_objectType(); public native btTypedObject m_objectType(int setter); - public native int getObjectType(); -} - -/**align a pointer to the provided alignment, upwards */ - -// #endif //BT_SCALAR_H - - -// Parsed from LinearMath/btVector3.h - -/* -Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_VECTOR3_H -// #define BT_VECTOR3_H - -//#include -// #include "btScalar.h" -// #include "btMinMax.h" -// #include "btAlignedAllocator.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btVector3Data btVector3FloatData -public static final String btVector3DataName = "btVector3FloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -// #if defined BT_USE_SSE - -// #endif - -// #ifdef BT_USE_NEON - -// #endif - -/**\brief btVector3 can be used to represent 3D points and vectors. - * It has an un-used w component to suit 16-byte alignment when btVector3 is stored in containers. This extra component can be used by derived classes (Quaternion?) or by user - * Ideally, this class should be replaced by a platform optimized SIMD version that keeps the data in registers - */ -@NoOffset public static class btVector3 extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVector3(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btVector3(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btVector3 position(long position) { - return (btVector3)super.position(position); - } - @Override public btVector3 getPointer(long i) { - return new btVector3((Pointer)this).offsetAddress(i); - } - - -// #if defined(__SPU__) && defined(__CELLOS_LV2__) -// #else //__CELLOS_LV2__ __SPU__ -// #if defined(BT_USE_SSE) || defined(BT_USE_NEON) // _WIN32 || ARM -// #else - public native @Cast("btScalar") float m_floats(int i); public native btVector3 m_floats(int i, float setter); - @MemberGetter public native @Cast("btScalar*") FloatPointer m_floats(); - /**\brief No initialization constructor */ - public btVector3() { super((Pointer)null); allocate(); } - private native void allocate(); - - /**\brief Constructor from scalars - * @param x X value - * @param y Y value - * @param z Z value - */ - public btVector3(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z) { super((Pointer)null); allocate(_x, _y, _z); } - private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); - -// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) -// #endif // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON) - - /**\brief Add a vector to this one - * @param The vector to add to this one */ - public native @ByRef @Name("operator +=") btVector3 addPut(@Const @ByRef btVector3 v); - - /**\brief Subtract a vector from this one - * @param The vector to subtract */ - public native @ByRef @Name("operator -=") btVector3 subtractPut(@Const @ByRef btVector3 v); - - /**\brief Scale the vector - * @param s Scale factor */ - public native @ByRef @Name("operator *=") btVector3 multiplyPut(@Cast("const btScalar") float s); - - /**\brief Inversely scale the vector - * @param s Scale factor to divide by */ - public native @ByRef @Name("operator /=") btVector3 dividePut(@Cast("const btScalar") float s); - - /**\brief Return the dot product - * @param v The other vector in the dot product */ - public native @Cast("btScalar") float dot(@Const @ByRef btVector3 v); - - /**\brief Return the length of the vector squared */ - public native @Cast("btScalar") float length2(); - - /**\brief Return the length of the vector */ - public native @Cast("btScalar") float length(); - - /**\brief Return the norm (length) of the vector */ - public native @Cast("btScalar") float norm(); - - /**\brief Return the norm (length) of the vector */ - public native @Cast("btScalar") float safeNorm(); - - /**\brief Return the distance squared between the ends of this and another vector - * This is symantically treating the vector like a point */ - public native @Cast("btScalar") float distance2(@Const @ByRef btVector3 v); - - /**\brief Return the distance between the ends of this and another vector - * This is symantically treating the vector like a point */ - public native @Cast("btScalar") float distance(@Const @ByRef btVector3 v); - - public native @ByRef btVector3 safeNormalize(); - - /**\brief Normalize this vector - * x^2 + y^2 + z^2 = 1 */ - public native @ByRef btVector3 normalize(); - - /**\brief Return a normalized version of this vector */ - public native @ByVal btVector3 normalized(); - - /**\brief Return a rotated version of this vector - * @param wAxis The axis to rotate about - * @param angle The angle to rotate by */ - public native @ByVal btVector3 rotate(@Const @ByRef btVector3 wAxis, @Cast("const btScalar") float angle); - - /**\brief Return the angle between this and another vector - * @param v The other vector */ - public native @Cast("btScalar") float angle(@Const @ByRef btVector3 v); - - /**\brief Return a vector with the absolute values of each element */ - public native @ByVal btVector3 absolute(); - - /**\brief Return the cross product between this and another vector - * @param v The other vector */ - public native @ByVal btVector3 cross(@Const @ByRef btVector3 v); - - public native @Cast("btScalar") float triple(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - - /**\brief Return the axis with the smallest value - * Note return values are 0,1,2 for x, y, or z */ - public native int minAxis(); - - /**\brief Return the axis with the largest value - * Note return values are 0,1,2 for x, y, or z */ - public native int maxAxis(); - - public native int furthestAxis(); - - public native int closestAxis(); - - public native void setInterpolate3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Cast("btScalar") float rt); - - /**\brief Return the linear interpolation between this and another vector - * @param v The other vector - * @param t The ration of this to v (t = 0 => return this, t=1 => return other) */ - public native @ByVal btVector3 lerp(@Const @ByRef btVector3 v, @Cast("const btScalar") float t); - - /**\brief Elementwise multiply this vector by the other - * @param v The other vector */ - public native @ByRef @Name("operator *=") btVector3 multiplyPut(@Const @ByRef btVector3 v); - - /**\brief Return the x value */ - public native @Cast("const btScalar") float getX(); - /**\brief Return the y value */ - public native @Cast("const btScalar") float getY(); - /**\brief Return the z value */ - public native @Cast("const btScalar") float getZ(); - /**\brief Set the x value */ - public native void setX(@Cast("btScalar") float _x); - /**\brief Set the y value */ - public native void setY(@Cast("btScalar") float _y); - /**\brief Set the z value */ - public native void setZ(@Cast("btScalar") float _z); - /**\brief Set the w value */ - public native void setW(@Cast("btScalar") float _w); - /**\brief Return the x value */ - public native @Cast("const btScalar") float x(); - /**\brief Return the y value */ - public native @Cast("const btScalar") float y(); - /**\brief Return the z value */ - public native @Cast("const btScalar") float z(); - /**\brief Return the w value */ - public native @Cast("const btScalar") float w(); - - //SIMD_FORCE_INLINE btScalar& operator[](int i) { return (&m_floats[0])[i]; } - //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; } - /**operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. */ - public native @Cast("btScalar*") @Name("operator btScalar*") FloatPointer asFloatPointer(); - - public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btVector3 other); - - public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef btVector3 other); - - /**\brief Set each element to the max of the current values and the values of another btVector3 - * @param other The other btVector3 to compare with - */ - public native void setMax(@Const @ByRef btVector3 other); - - /**\brief Set each element to the min of the current values and the values of another btVector3 - * @param other The other btVector3 to compare with - */ - public native void setMin(@Const @ByRef btVector3 other); - - public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); - - public native void getSkewSymmetricMatrix(btVector3 v0, btVector3 v1, btVector3 v2); - - public native void setZero(); - - public native @Cast("bool") boolean isZero(); - - public native @Cast("bool") boolean fuzzyZero(); - - public native void serialize(@ByRef btVector3FloatData dataOut); - - public native void deSerialize(@Const @ByRef btVector3DoubleData dataIn); - - public native void deSerialize(@Const @ByRef btVector3FloatData dataIn); - - public native void serializeFloat(@ByRef btVector3FloatData dataOut); - - public native void deSerializeFloat(@Const @ByRef btVector3FloatData dataIn); - - public native void serializeDouble(@ByRef btVector3DoubleData dataOut); - - public native void deSerializeDouble(@Const @ByRef btVector3DoubleData dataIn); - - /**\brief returns index of maximum dot product between this and vectors in array[] - * @param array The other vectors - * @param array_count The number of other vectors - * @param dotOut The maximum dot product */ - public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatPointer dotOut); - public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatBuffer dotOut); - public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef float[] dotOut); - - /**\brief returns index of minimum dot product between this and vectors in array[] - * @param array The other vectors - * @param array_count The number of other vectors - * @param dotOut The minimum dot product */ - public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatPointer dotOut); - public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatBuffer dotOut); - public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef float[] dotOut); - - /* create a vector as btVector3( this->dot( btVector3 v0 ), this->dot( btVector3 v1), this->dot( btVector3 v2 )) */ - public native @ByVal btVector3 dot3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); -} - -/**\brief Return the sum of two vectors (Point symantics)*/ -public static native @ByVal @Name("operator +") btVector3 add(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -/**\brief Return the elementwise product of two vectors */ -public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -/**\brief Return the difference between two vectors */ -public static native @ByVal @Name("operator -") btVector3 subtract(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -/**\brief Return the negative of the vector */ -public static native @ByVal @Name("operator -") btVector3 subtract(@Const @ByRef btVector3 v); - -/**\brief Return the vector scaled by s */ -public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v, @Cast("const btScalar") float s); - -/**\brief Return the vector scaled by s */ -public static native @ByVal @Name("operator *") btVector3 multiply(@Cast("const btScalar") float s, @Const @ByRef btVector3 v); - -/**\brief Return the vector inversely scaled by s */ -public static native @ByVal @Name("operator /") btVector3 divide(@Const @ByRef btVector3 v, @Cast("const btScalar") float s); - -/**\brief Return the vector inversely scaled by s */ -public static native @ByVal @Name("operator /") btVector3 divide(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -/**\brief Return the dot product between two vectors */ -public static native @Cast("btScalar") float btDot(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -/**\brief Return the distance squared between two vectors */ -public static native @Cast("btScalar") float btDistance2(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -/**\brief Return the distance between two vectors */ -public static native @Cast("btScalar") float btDistance(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -/**\brief Return the angle between two vectors */ -public static native @Cast("btScalar") float btAngle(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -/**\brief Return the cross product of two vectors */ -public static native @ByVal btVector3 btCross(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -public static native @Cast("btScalar") float btTriple(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 v3); - -/**\brief Return the linear interpolation between two vectors - * @param v1 One vector - * @param v2 The other vector - * @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */ -public static native @ByVal btVector3 lerp(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Cast("const btScalar") float t); - - - - - - - - - - - - - -public static class btVector4 extends btVector3 { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVector4(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btVector4(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btVector4 position(long position) { - return (btVector4)super.position(position); - } - @Override public btVector4 getPointer(long i) { - return new btVector4((Pointer)this).offsetAddress(i); - } - - public btVector4() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btVector4(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } - private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); - -// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) -// #endif // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON) - - public native @ByVal btVector4 absolute4(); - - public native @Cast("btScalar") float getW(); - - public native int maxAxis4(); - - public native int minAxis4(); - - public native int closestAxis4(); - - /**\brief Set x,y,z and zero w - * @param x Value of x - * @param y Value of y - * @param z Value of z - */ - - /* void getValue(btScalar *m) const - { - m[0] = m_floats[0]; - m[1] = m_floats[1]; - m[2] =m_floats[2]; - } -*/ - /**\brief Set the values - * @param x Value of x - * @param y Value of y - * @param z Value of z - * @param w Value of w - */ - public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); -} - -/**btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ -public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef FloatPointer destVal); -public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef FloatBuffer destVal); -public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef float[] destVal); -/**btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ -public static native void btSwapVector3Endian(@Const @ByRef btVector3 sourceVec, @ByRef btVector3 destVec); - -/**btUnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ -public static native void btUnSwapVector3Endian(@ByRef btVector3 vector); - -public static class btVector3FloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btVector3FloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btVector3FloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVector3FloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btVector3FloatData position(long position) { - return (btVector3FloatData)super.position(position); - } - @Override public btVector3FloatData getPointer(long i) { - return new btVector3FloatData((Pointer)this).offsetAddress(i); - } - - public native float m_floats(int i); public native btVector3FloatData m_floats(int i, float setter); - @MemberGetter public native FloatPointer m_floats(); -} - -public static class btVector3DoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btVector3DoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btVector3DoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVector3DoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btVector3DoubleData position(long position) { - return (btVector3DoubleData)super.position(position); - } - @Override public btVector3DoubleData getPointer(long i) { - return new btVector3DoubleData((Pointer)this).offsetAddress(i); - } - - public native double m_floats(int i); public native btVector3DoubleData m_floats(int i, double setter); - @MemberGetter public native DoublePointer m_floats(); -} - - - - - - - - - - - - - - - -// #endif //BT_VECTOR3_H - - -// Parsed from LinearMath/btQuadWord.h - -/* -Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SIMD_QUADWORD_H -// #define BT_SIMD_QUADWORD_H - -// #include "btScalar.h" -// #include "btMinMax.h" - -// #if defined(__CELLOS_LV2) && defined(__SPU__) -// #include -// #endif - -/**\brief The btQuadWord class is base class for btVector3 and btQuaternion. - * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword. - */ -// #ifndef USE_LIBSPE2 -@NoOffset public static class btQuadWord extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuadWord(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuadWord(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btQuadWord position(long position) { - return (btQuadWord)super.position(position); - } - @Override public btQuadWord getPointer(long i) { - return new btQuadWord((Pointer)this).offsetAddress(i); - } - -// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) - -// #endif - - /**\brief Return the x value */ - public native @Cast("const btScalar") float getX(); - /**\brief Return the y value */ - public native @Cast("const btScalar") float getY(); - /**\brief Return the z value */ - public native @Cast("const btScalar") float getZ(); - /**\brief Set the x value */ - public native void setX(@Cast("btScalar") float _x); - /**\brief Set the y value */ - public native void setY(@Cast("btScalar") float _y); - /**\brief Set the z value */ - public native void setZ(@Cast("btScalar") float _z); - /**\brief Set the w value */ - public native void setW(@Cast("btScalar") float _w); - /**\brief Return the x value */ - public native @Cast("const btScalar") float x(); - /**\brief Return the y value */ - public native @Cast("const btScalar") float y(); - /**\brief Return the z value */ - public native @Cast("const btScalar") float z(); - /**\brief Return the w value */ - public native @Cast("const btScalar") float w(); - - //SIMD_FORCE_INLINE btScalar& operator[](int i) { return (&m_floats[0])[i]; } - //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; } - /**operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. */ - public native @Cast("btScalar*") @Name("operator btScalar*") FloatPointer asFloatPointer(); - - public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btQuadWord other); - - public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef btQuadWord other); - - /**\brief Set x,y,z and zero w - * @param x Value of x - * @param y Value of y - * @param z Value of z - */ - public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); - - /* void getValue(btScalar *m) const - { - m[0] = m_floats[0]; - m[1] = m_floats[1]; - m[2] = m_floats[2]; - } -*/ - /**\brief Set the values - * @param x Value of x - * @param y Value of y - * @param z Value of z - * @param w Value of w - */ - public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); - /**\brief No initialization constructor */ - public btQuadWord() { super((Pointer)null); allocate(); } - private native void allocate(); - - /**\brief Three argument constructor (zeros w) - * @param x Value of x - * @param y Value of y - * @param z Value of z - */ - public btQuadWord(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z) { super((Pointer)null); allocate(_x, _y, _z); } - private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); - - /**\brief Initializing constructor - * @param x Value of x - * @param y Value of y - * @param z Value of z - * @param w Value of w - */ - public btQuadWord(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } - private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); - - /**\brief Set each element to the max of the current values and the values of another btQuadWord - * @param other The other btQuadWord to compare with - */ - public native void setMax(@Const @ByRef btQuadWord other); - /**\brief Set each element to the min of the current values and the values of another btQuadWord - * @param other The other btQuadWord to compare with - */ - public native void setMin(@Const @ByRef btQuadWord other); -} - -// #endif //BT_SIMD_QUADWORD_H - - -// Parsed from LinearMath/btQuaternion.h - -/* -Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SIMD__QUATERNION_H_ -// #define BT_SIMD__QUATERNION_H_ - -// #include "btVector3.h" -// #include "btQuadWord.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btQuaternionData btQuaternionFloatData -public static final String btQuaternionDataName = "btQuaternionFloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -// #ifdef BT_USE_SSE - -// #endif - -// #if defined(BT_USE_SSE) - -// #elif defined(BT_USE_NEON) - -// #endif - -/**\brief The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatrix3x3, btVector3 and btTransform. */ -public static class btQuaternion extends btQuadWord { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuaternion(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuaternion(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btQuaternion position(long position) { - return (btQuaternion)super.position(position); - } - @Override public btQuaternion getPointer(long i) { - return new btQuaternion((Pointer)this).offsetAddress(i); - } - - /**\brief No initialization constructor */ - public btQuaternion() { super((Pointer)null); allocate(); } - private native void allocate(); - -// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) - -// #endif - - // template - // explicit Quaternion(const btScalar *v) : Tuple4(v) {} - /**\brief Constructor from scalars */ - public btQuaternion(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } - private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); - /**\brief Axis angle Constructor - * @param axis The axis which the rotation is around - * @param angle The magnitude of the rotation around the angle (Radians) */ - public btQuaternion(@Const @ByRef btVector3 _axis, @Cast("const btScalar") float _angle) { super((Pointer)null); allocate(_axis, _angle); } - private native void allocate(@Const @ByRef btVector3 _axis, @Cast("const btScalar") float _angle); - /**\brief Constructor from Euler angles - * @param yaw Angle around Y unless BT_EULER_DEFAULT_ZYX defined then Z - * @param pitch Angle around X unless BT_EULER_DEFAULT_ZYX defined then Y - * @param roll Angle around Z unless BT_EULER_DEFAULT_ZYX defined then X */ - public btQuaternion(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll) { super((Pointer)null); allocate(yaw, pitch, roll); } - private native void allocate(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); - /**\brief Set the rotation using axis angle notation - * @param axis The axis around which to rotate - * @param angle The magnitude of the rotation in Radians */ - public native void setRotation(@Const @ByRef btVector3 axis, @Cast("const btScalar") float _angle); - /**\brief Set the quaternion using Euler angles - * @param yaw Angle around Y - * @param pitch Angle around X - * @param roll Angle around Z */ - public native void setEuler(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); - /**\brief Set the quaternion using euler angles - * @param yaw Angle around Z - * @param pitch Angle around Y - * @param roll Angle around X */ - public native void setEulerZYX(@Cast("const btScalar") float yawZ, @Cast("const btScalar") float pitchY, @Cast("const btScalar") float rollX); - - /**\brief Get the euler angles from this quaternion - * @param yaw Angle around Z - * @param pitch Angle around Y - * @param roll Angle around X */ - public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yawZ, @Cast("btScalar*") @ByRef FloatPointer pitchY, @Cast("btScalar*") @ByRef FloatPointer rollX); - public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yawZ, @Cast("btScalar*") @ByRef FloatBuffer pitchY, @Cast("btScalar*") @ByRef FloatBuffer rollX); - public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yawZ, @Cast("btScalar*") @ByRef float[] pitchY, @Cast("btScalar*") @ByRef float[] rollX); - - /**\brief Add two quaternions - * @param q The quaternion to add to this one */ - public native @ByRef @Name("operator +=") btQuaternion addPut(@Const @ByRef btQuaternion q); - - /**\brief Subtract out a quaternion - * @param q The quaternion to subtract from this one */ - public native @ByRef @Name("operator -=") btQuaternion subtractPut(@Const @ByRef btQuaternion q); - - /**\brief Scale this quaternion - * @param s The scalar to scale by */ - public native @ByRef @Name("operator *=") btQuaternion multiplyPut(@Cast("const btScalar") float s); - - /**\brief Multiply this quaternion by q on the right - * @param q The other quaternion - * Equivilant to this = this * q */ - public native @ByRef @Name("operator *=") btQuaternion multiplyPut(@Const @ByRef btQuaternion q); - /**\brief Return the dot product between this quaternion and another - * @param q The other quaternion */ - public native @Cast("btScalar") float dot(@Const @ByRef btQuaternion q); - - /**\brief Return the length squared of the quaternion */ - public native @Cast("btScalar") float length2(); - - /**\brief Return the length of the quaternion */ - public native @Cast("btScalar") float length(); - public native @ByRef btQuaternion safeNormalize(); - /**\brief Normalize the quaternion - * Such that x^2 + y^2 + z^2 +w^2 = 1 */ - public native @ByRef btQuaternion normalize(); - - /**\brief Return a scaled version of this quaternion - * @param s The scale factor */ - public native @ByVal @Name("operator *") btQuaternion multiply(@Cast("const btScalar") float s); - - /**\brief Return an inversely scaled versionof this quaternion - * @param s The inverse scale factor */ - public native @ByVal @Name("operator /") btQuaternion divide(@Cast("const btScalar") float s); - - /**\brief Inversely scale this quaternion - * @param s The scale factor */ - public native @ByRef @Name("operator /=") btQuaternion dividePut(@Cast("const btScalar") float s); - - /**\brief Return a normalized version of this quaternion */ - public native @ByVal btQuaternion normalized(); - /**\brief Return the ***half*** angle between this quaternion and the other - * @param q The other quaternion */ - public native @Cast("btScalar") float angle(@Const @ByRef btQuaternion q); - - /**\brief Return the angle between this quaternion and the other along the shortest path - * @param q The other quaternion */ - public native @Cast("btScalar") float angleShortestPath(@Const @ByRef btQuaternion q); - - /**\brief Return the angle [0, 2Pi] of rotation represented by this quaternion */ - public native @Cast("btScalar") float getAngle(); - - /**\brief Return the angle [0, Pi] of rotation represented by this quaternion along the shortest path */ - public native @Cast("btScalar") float getAngleShortestPath(); - - /**\brief Return the axis of the rotation represented by this quaternion */ - public native @ByVal btVector3 getAxis(); - - /**\brief Return the inverse of this quaternion */ - public native @ByVal btQuaternion inverse(); - - /**\brief Return the sum of this quaternion and the other - * @param q2 The other quaternion */ - public native @ByVal @Name("operator +") btQuaternion add(@Const @ByRef btQuaternion q2); - - /**\brief Return the difference between this quaternion and the other - * @param q2 The other quaternion */ - public native @ByVal @Name("operator -") btQuaternion subtract(@Const @ByRef btQuaternion q2); - - /**\brief Return the negative of this quaternion - * This simply negates each element */ - public native @ByVal @Name("operator -") btQuaternion subtract(); - /**\todo document this and it's use */ - public native @ByVal btQuaternion farthest(@Const @ByRef btQuaternion qd); - - /**\todo document this and it's use */ - public native @ByVal btQuaternion nearest(@Const @ByRef btQuaternion qd); - - /**\brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion - * @param q The other quaternion to interpolate with - * @param t The ratio between this and q to interpolate. If t = 0 the result is this, if t=1 the result is q. - * Slerp interpolates assuming constant velocity. */ - public native @ByVal btQuaternion slerp(@Const @ByRef btQuaternion q, @Cast("const btScalar") float t); - - public static native @Const @ByRef btQuaternion getIdentity(); - - public native @Cast("const btScalar") float getW(); - - public native void serialize(@ByRef btQuaternionFloatData dataOut); - - public native void deSerialize(@Const @ByRef btQuaternionFloatData dataIn); - - public native void deSerialize(@Const @ByRef btQuaternionDoubleData dataIn); - - public native void serializeFloat(@ByRef btQuaternionFloatData dataOut); - - public native void deSerializeFloat(@Const @ByRef btQuaternionFloatData dataIn); - - public native void serializeDouble(@ByRef btQuaternionDoubleData dataOut); - - public native void deSerializeDouble(@Const @ByRef btQuaternionDoubleData dataIn); -} - -/**\brief Return the product of two quaternions */ -public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); - -public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q, @Const @ByRef btVector3 w); - -public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btVector3 w, @Const @ByRef btQuaternion q); - -/**\brief Calculate the dot product between two quaternions */ -public static native @Cast("btScalar") float dot(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); - -/**\brief Return the length of a quaternion */ -public static native @Cast("btScalar") float length(@Const @ByRef btQuaternion q); - -/**\brief Return the angle between two quaternions*/ -public static native @Cast("btScalar") float btAngle(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); - -/**\brief Return the inverse of a quaternion*/ -public static native @ByVal btQuaternion inverse(@Const @ByRef btQuaternion q); - -/**\brief Return the result of spherical linear interpolation betwen two quaternions - * @param q1 The first quaternion - * @param q2 The second quaternion - * @param t The ration between q1 and q2. t = 0 return q1, t=1 returns q2 - * Slerp assumes constant velocity between positions. */ -public static native @ByVal btQuaternion slerp(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2, @Cast("const btScalar") float t); - -public static native @ByVal btVector3 quatRotate(@Const @ByRef btQuaternion rotation, @Const @ByRef btVector3 v); - -public static native @ByVal btQuaternion shortestArcQuat(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1); - -public static native @ByVal btQuaternion shortestArcQuatNormalize2(@ByRef btVector3 v0, @ByRef btVector3 v1); - -public static class btQuaternionFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btQuaternionFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuaternionFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuaternionFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btQuaternionFloatData position(long position) { - return (btQuaternionFloatData)super.position(position); - } - @Override public btQuaternionFloatData getPointer(long i) { - return new btQuaternionFloatData((Pointer)this).offsetAddress(i); - } - - public native float m_floats(int i); public native btQuaternionFloatData m_floats(int i, float setter); - @MemberGetter public native FloatPointer m_floats(); -} - -public static class btQuaternionDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btQuaternionDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btQuaternionDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btQuaternionDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btQuaternionDoubleData position(long position) { - return (btQuaternionDoubleData)super.position(position); - } - @Override public btQuaternionDoubleData getPointer(long i) { - return new btQuaternionDoubleData((Pointer)this).offsetAddress(i); - } - - public native double m_floats(int i); public native btQuaternionDoubleData m_floats(int i, double setter); - @MemberGetter public native DoublePointer m_floats(); -} - - - - - - - - - - - - - - - -// #endif //BT_SIMD__QUATERNION_H_ - - -// Parsed from LinearMath/btMatrix3x3.h - -/* -Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_MATRIX3x3_H -// #define BT_MATRIX3x3_H - -// #include "btVector3.h" -// #include "btQuaternion.h" -// #include - -// #ifdef BT_USE_SSE -// #endif - -// #if defined(BT_USE_SSE) -// #elif defined(BT_USE_NEON) -// #endif - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btMatrix3x3Data btMatrix3x3FloatData -// #endif //BT_USE_DOUBLE_PRECISION - -/**\brief The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with btQuaternion, btTransform and btVector3. -* Make sure to only include a pure orthogonal matrix without scaling. */ -@NoOffset public static class btMatrix3x3 extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btMatrix3x3(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btMatrix3x3(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btMatrix3x3 position(long position) { - return (btMatrix3x3)super.position(position); - } - @Override public btMatrix3x3 getPointer(long i) { - return new btMatrix3x3((Pointer)this).offsetAddress(i); - } - - /** \brief No initializaion constructor */ - public btMatrix3x3() { super((Pointer)null); allocate(); } - private native void allocate(); - - // explicit btMatrix3x3(const btScalar *m) { setFromOpenGLSubMatrix(m); } - - /**\brief Constructor from Quaternion */ - public btMatrix3x3(@Const @ByRef btQuaternion q) { super((Pointer)null); allocate(q); } - private native void allocate(@Const @ByRef btQuaternion q); - /* - template - Matrix3x3(const btScalar& yaw, const btScalar& pitch, const btScalar& roll) - { - setEulerYPR(yaw, pitch, roll); - } - */ - /** \brief Constructor with row major formatting */ - public btMatrix3x3(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, - @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, - @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz) { super((Pointer)null); allocate(xx, xy, xz, yx, yy, yz, zx, zy, zz); } - private native void allocate(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, - @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, - @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz); - -// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) - -// #else - - /** \brief Copy constructor */ - public btMatrix3x3(@Const @ByRef btMatrix3x3 other) { super((Pointer)null); allocate(other); } - private native void allocate(@Const @ByRef btMatrix3x3 other); - - /** \brief Assignment Operator */ - public native @ByRef @Name("operator =") btMatrix3x3 put(@Const @ByRef btMatrix3x3 other); - - public btMatrix3x3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2) { super((Pointer)null); allocate(v0, v1, v2); } - private native void allocate(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); - -// #endif - - /** \brief Get a column of the matrix as a vector - * @param i Column number 0 indexed */ - public native @ByVal btVector3 getColumn(int i); - - /** \brief Get a row of the matrix as a vector - * @param i Row number 0 indexed */ - public native @Const @ByRef btVector3 getRow(int i); - - /** \brief Get a mutable reference to a row of the matrix as a vector - * @param i Row number 0 indexed */ - public native @ByRef @Name("operator []") btVector3 get(int i); - - /** \brief Get a const reference to a row of the matrix as a vector - * @param i Row number 0 indexed */ - - /** \brief Multiply by the target matrix on the right - * @param m Rotation matrix to be applied - * Equivilant to this = this * m */ - public native @ByRef @Name("operator *=") btMatrix3x3 multiplyPut(@Const @ByRef btMatrix3x3 m); - - /** \brief Adds by the target matrix on the right - * @param m matrix to be applied - * Equivilant to this = this + m */ - public native @ByRef @Name("operator +=") btMatrix3x3 addPut(@Const @ByRef btMatrix3x3 m); - - /** \brief Substractss by the target matrix on the right - * @param m matrix to be applied - * Equivilant to this = this - m */ - public native @ByRef @Name("operator -=") btMatrix3x3 subtractPut(@Const @ByRef btMatrix3x3 m); - - /** \brief Set from the rotational part of a 4x4 OpenGL matrix - * @param m A pointer to the beginning of the array of scalars*/ - public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") FloatPointer m); - public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") FloatBuffer m); - public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") float[] m); - /** \brief Set the values of the matrix explicitly (row major) - * @param xx Top left - * @param xy Top Middle - * @param xz Top Right - * @param yx Middle Left - * @param yy Middle Middle - * @param yz Middle Right - * @param zx Bottom Left - * @param zy Bottom Middle - * @param zz Bottom Right*/ - public native void setValue(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, - @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, - @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz); - - /** \brief Set the matrix from a quaternion - * @param q The Quaternion to match */ - public native void setRotation(@Const @ByRef btQuaternion q); - - /** \brief Set the matrix from euler angles using YPR around YXZ respectively - * @param yaw Yaw about Y axis - * @param pitch Pitch about X axis - * @param roll Roll about Z axis - */ - public native void setEulerYPR(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); - - /** \brief Set the matrix from euler angles YPR around ZYX axes - * @param eulerX Roll about X axis - * @param eulerY Pitch around Y axis - * @param eulerZ Yaw about Z axis - * - * These angles are used to produce a rotation matrix. The euler - * angles are applied in ZYX order. I.e a vector is first rotated - * about X then Y and then Z - **/ - public native void setEulerZYX(@Cast("btScalar") float eulerX, @Cast("btScalar") float eulerY, @Cast("btScalar") float eulerZ); - - /**\brief Set the matrix to the identity */ - public native void setIdentity(); - - /**\brief Set the matrix to the identity */ - public native void setZero(); - - public static native @Const @ByRef btMatrix3x3 getIdentity(); - - /**\brief Fill the rotational part of an OpenGL matrix and clear the shear/perspective - * @param m The array to be filled */ - public native void getOpenGLSubMatrix(@Cast("btScalar*") FloatPointer m); - public native void getOpenGLSubMatrix(@Cast("btScalar*") FloatBuffer m); - public native void getOpenGLSubMatrix(@Cast("btScalar*") float[] m); - - /**\brief Get the matrix represented as a quaternion - * @param q The quaternion which will be set */ - public native void getRotation(@ByRef btQuaternion q); - - /**\brief Get the matrix represented as euler angles around YXZ, roundtrip with setEulerYPR - * @param yaw Yaw around Y axis - * @param pitch Pitch around X axis - * @param roll around Z axis */ - public native void getEulerYPR(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll); - public native void getEulerYPR(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll); - public native void getEulerYPR(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll); - - /**\brief Get the matrix represented as euler angles around ZYX - * @param yaw Yaw around Z axis - * @param pitch Pitch around Y axis - * @param roll around X axis - * @param solution_number Which solution of two possible solutions ( 1 or 2) are possible values*/ - public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll, @Cast("unsigned int") int solution_number/*=1*/); - public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll); - public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll, @Cast("unsigned int") int solution_number/*=1*/); - public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll); - public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll, @Cast("unsigned int") int solution_number/*=1*/); - public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll); - - /**\brief Create a scaled copy of the matrix - * @param s Scaling vector The elements of the vector will scale each column */ - - public native @ByVal btMatrix3x3 scaled(@Const @ByRef btVector3 s); - - /**\brief Return the determinant of the matrix */ - public native @Cast("btScalar") float determinant(); - /**\brief Return the adjoint of the matrix */ - public native @ByVal btMatrix3x3 adjoint(); - /**\brief Return the matrix with all values non negative */ - public native @ByVal btMatrix3x3 absolute(); - /**\brief Return the transpose of the matrix */ - public native @ByVal btMatrix3x3 transpose(); - /**\brief Return the inverse of the matrix */ - public native @ByVal btMatrix3x3 inverse(); - - /** Solve A * x = b, where b is a column vector. This is more efficient - * than computing the inverse in one-shot cases. - * Solve33 is from Box2d, thanks to Erin Catto, */ - public native @ByVal btVector3 solve33(@Const @ByRef btVector3 b); - - public native @ByVal btMatrix3x3 transposeTimes(@Const @ByRef btMatrix3x3 m); - public native @ByVal btMatrix3x3 timesTranspose(@Const @ByRef btMatrix3x3 m); - - public native @Cast("btScalar") float tdotx(@Const @ByRef btVector3 v); - public native @Cast("btScalar") float tdoty(@Const @ByRef btVector3 v); - public native @Cast("btScalar") float tdotz(@Const @ByRef btVector3 v); - - /**extractRotation is from "A robust method to extract the rotational part of deformations" - * See http://dl.acm.org/citation.cfm?doid=2994258.2994269 - * decomposes a matrix A in a orthogonal matrix R and a - * symmetric matrix S: - * A = R*S. - * note that R can include both rotation and scaling. */ - public native void extractRotation(@ByRef btQuaternion q, @Cast("btScalar") float tolerance/*=1.0e-9*/, int maxIter/*=100*/); - public native void extractRotation(@ByRef btQuaternion q); - - /**\brief diagonalizes this matrix by the Jacobi method. - * @param rot stores the rotation from the coordinate system in which the matrix is diagonal to the original - * coordinate system, i.e., old_this = rot * new_this * rot^T. - * @param threshold See iteration - * @param iteration The iteration stops when all off-diagonal elements are less than the threshold multiplied - * by the sum of the absolute values of the diagonal, or when maxSteps have been executed. - * - * Note that this matrix is assumed to be symmetric. - */ - public native void diagonalize(@ByRef btMatrix3x3 rot, @Cast("btScalar") float threshold, int maxSteps); - - /**\brief Calculate the matrix cofactor - * @param r1 The first row to use for calculating the cofactor - * @param c1 The first column to use for calculating the cofactor - * @param r1 The second row to use for calculating the cofactor - * @param c1 The second column to use for calculating the cofactor - * See http://en.wikipedia.org/wiki/Cofactor_(linear_algebra) for more details - */ - public native @Cast("btScalar") float cofac(int r1, int c1, int r2, int c2); - - public native void serialize(@ByRef btMatrix3x3FloatData dataOut); - - public native void serializeFloat(@ByRef btMatrix3x3FloatData dataOut); - - public native void deSerialize(@Const @ByRef btMatrix3x3FloatData dataIn); - - public native void deSerializeFloat(@Const @ByRef btMatrix3x3FloatData dataIn); - - public native void deSerializeDouble(@Const @ByRef btMatrix3x3DoubleData dataIn); -} - - - - - -public static native @ByVal @Name("operator *") btMatrix3x3 multiply(@Const @ByRef btMatrix3x3 m, @Cast("const btScalar") float k); - -public static native @ByVal @Name("operator +") btMatrix3x3 add(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); - -public static native @ByVal @Name("operator -") btMatrix3x3 subtract(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); - - - - - - - - - - - - - - - - - -public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btMatrix3x3 m, @Const @ByRef btVector3 v); - -public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v, @Const @ByRef btMatrix3x3 m); - -public static native @ByVal @Name("operator *") btMatrix3x3 multiply(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); - -/* -SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const btMatrix3x3& m2) { -return btMatrix3x3( -m1[0][0] * m2[0][0] + m1[1][0] * m2[1][0] + m1[2][0] * m2[2][0], -m1[0][0] * m2[0][1] + m1[1][0] * m2[1][1] + m1[2][0] * m2[2][1], -m1[0][0] * m2[0][2] + m1[1][0] * m2[1][2] + m1[2][0] * m2[2][2], -m1[0][1] * m2[0][0] + m1[1][1] * m2[1][0] + m1[2][1] * m2[2][0], -m1[0][1] * m2[0][1] + m1[1][1] * m2[1][1] + m1[2][1] * m2[2][1], -m1[0][1] * m2[0][2] + m1[1][1] * m2[1][2] + m1[2][1] * m2[2][2], -m1[0][2] * m2[0][0] + m1[1][2] * m2[1][0] + m1[2][2] * m2[2][0], -m1[0][2] * m2[0][1] + m1[1][2] * m2[1][1] + m1[2][2] * m2[2][1], -m1[0][2] * m2[0][2] + m1[1][2] * m2[1][2] + m1[2][2] * m2[2][2]); -} -*/ - -/**\brief Equality operator between two matrices -* It will test all elements are equal. */ -public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); - -/**for serialization */ -public static class btMatrix3x3FloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btMatrix3x3FloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btMatrix3x3FloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btMatrix3x3FloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btMatrix3x3FloatData position(long position) { - return (btMatrix3x3FloatData)super.position(position); - } - @Override public btMatrix3x3FloatData getPointer(long i) { - return new btMatrix3x3FloatData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3FloatData m_el(int i); public native btMatrix3x3FloatData m_el(int i, btVector3FloatData setter); - @MemberGetter public native btVector3FloatData m_el(); -} - -/**for serialization */ -public static class btMatrix3x3DoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btMatrix3x3DoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btMatrix3x3DoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btMatrix3x3DoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btMatrix3x3DoubleData position(long position) { - return (btMatrix3x3DoubleData)super.position(position); - } - @Override public btMatrix3x3DoubleData getPointer(long i) { - return new btMatrix3x3DoubleData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3DoubleData m_el(int i); public native btMatrix3x3DoubleData m_el(int i, btVector3DoubleData setter); - @MemberGetter public native btVector3DoubleData m_el(); -} - - - - - - - - - - - -// #endif //BT_MATRIX3x3_H - - -// Parsed from LinearMath/btTransform.h - -/* -Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_TRANSFORM_H -// #define BT_TRANSFORM_H - -// #include "btMatrix3x3.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btTransformData btTransformFloatData -// #endif - -/**\brief The btTransform class supports rigid transforms with only translation and rotation and no scaling/shear. - *It can be used in combination with btVector3, btQuaternion and btMatrix3x3 linear algebra classes. */ -@NoOffset public static class btTransform extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTransform(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTransform(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btTransform position(long position) { - return (btTransform)super.position(position); - } - @Override public btTransform getPointer(long i) { - return new btTransform((Pointer)this).offsetAddress(i); - } - - /**\brief No initialization constructor */ - public btTransform() { super((Pointer)null); allocate(); } - private native void allocate(); - /**\brief Constructor from btQuaternion (optional btVector3 ) - * @param q Rotation from quaternion - * @param c Translation from Vector (default 0,0,0) */ - public btTransform(@Const @ByRef btQuaternion q, - @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c) { super((Pointer)null); allocate(q, c); } - private native void allocate(@Const @ByRef btQuaternion q, - @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c); - public btTransform(@Const @ByRef btQuaternion q) { super((Pointer)null); allocate(q); } - private native void allocate(@Const @ByRef btQuaternion q); - - /**\brief Constructor from btMatrix3x3 (optional btVector3) - * @param b Rotation from Matrix - * @param c Translation from Vector default (0,0,0)*/ - public btTransform(@Const @ByRef btMatrix3x3 b, - @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c) { super((Pointer)null); allocate(b, c); } - private native void allocate(@Const @ByRef btMatrix3x3 b, - @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c); - public btTransform(@Const @ByRef btMatrix3x3 b) { super((Pointer)null); allocate(b); } - private native void allocate(@Const @ByRef btMatrix3x3 b); - /**\brief Copy constructor */ - public btTransform(@Const @ByRef btTransform other) { super((Pointer)null); allocate(other); } - private native void allocate(@Const @ByRef btTransform other); - /**\brief Assignment Operator */ - public native @ByRef @Name("operator =") btTransform put(@Const @ByRef btTransform other); - - /**\brief Set the current transform as the value of the product of two transforms - * @param t1 Transform 1 - * @param t2 Transform 2 - * This = Transform1 * Transform2 */ - public native void mult(@Const @ByRef btTransform t1, @Const @ByRef btTransform t2); - - /* void multInverseLeft(const btTransform& t1, const btTransform& t2) { - btVector3 v = t2.m_origin - t1.m_origin; - m_basis = btMultTransposeLeft(t1.m_basis, t2.m_basis); - m_origin = v * t1.m_basis; - } - */ - - /**\brief Return the transform of the vector */ - public native @ByVal @Name("operator ()") btVector3 apply(@Const @ByRef btVector3 x); - - /**\brief Return the transform of the vector */ - public native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 x); - - /**\brief Return the transform of the btQuaternion */ - public native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q); - - /**\brief Return the basis matrix for the rotation */ - public native @ByRef btMatrix3x3 getBasis(); - /**\brief Return the basis matrix for the rotation */ - - /**\brief Return the origin vector translation */ - public native @ByRef btVector3 getOrigin(); - /**\brief Return the origin vector translation */ - - /**\brief Return a quaternion representing the rotation */ - public native @ByVal btQuaternion getRotation(); - - /**\brief Set from an array - * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */ - public native void setFromOpenGLMatrix(@Cast("const btScalar*") FloatPointer m); - public native void setFromOpenGLMatrix(@Cast("const btScalar*") FloatBuffer m); - public native void setFromOpenGLMatrix(@Cast("const btScalar*") float[] m); - - /**\brief Fill an array representation - * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */ - public native void getOpenGLMatrix(@Cast("btScalar*") FloatPointer m); - public native void getOpenGLMatrix(@Cast("btScalar*") FloatBuffer m); - public native void getOpenGLMatrix(@Cast("btScalar*") float[] m); - - /**\brief Set the translational element - * @param origin The vector to set the translation to */ - public native void setOrigin(@Const @ByRef btVector3 origin); - - public native @ByVal btVector3 invXform(@Const @ByRef btVector3 inVec); - - /**\brief Set the rotational element by btMatrix3x3 */ - public native void setBasis(@Const @ByRef btMatrix3x3 basis); - - /**\brief Set the rotational element by btQuaternion */ - public native void setRotation(@Const @ByRef btQuaternion q); - - /**\brief Set this transformation to the identity */ - public native void setIdentity(); - - /**\brief Multiply this Transform by another(this = this * another) - * @param t The other transform */ - public native @ByRef @Name("operator *=") btTransform multiplyPut(@Const @ByRef btTransform t); - - /**\brief Return the inverse of this transform */ - public native @ByVal btTransform inverse(); - - /**\brief Return the inverse of this transform times the other transform - * @param t The other transform - * return this.inverse() * the other */ - public native @ByVal btTransform inverseTimes(@Const @ByRef btTransform t); - - /**\brief Return the product of this transform and the other */ - public native @ByVal @Name("operator *") btTransform multiply(@Const @ByRef btTransform t); - - /**\brief Return an identity transform */ - public static native @Const @ByRef btTransform getIdentity(); - - public native void serialize(@ByRef btTransformFloatData dataOut); - - public native void serializeFloat(@ByRef btTransformFloatData dataOut); - - public native void deSerialize(@Const @ByRef btTransformFloatData dataIn); - - public native void deSerializeDouble(@Const @ByRef btTransformDoubleData dataIn); - - public native void deSerializeFloat(@Const @ByRef btTransformFloatData dataIn); -} - - - - - - - -/**\brief Test if two transforms have all elements equal */ -public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btTransform t1, @Const @ByRef btTransform t2); - -/**for serialization */ -public static class btTransformFloatData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btTransformFloatData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTransformFloatData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTransformFloatData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btTransformFloatData position(long position) { - return (btTransformFloatData)super.position(position); - } - @Override public btTransformFloatData getPointer(long i) { - return new btTransformFloatData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btMatrix3x3FloatData m_basis(); public native btTransformFloatData m_basis(btMatrix3x3FloatData setter); - public native @ByRef btVector3FloatData m_origin(); public native btTransformFloatData m_origin(btVector3FloatData setter); -} - -public static class btTransformDoubleData extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btTransformDoubleData() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btTransformDoubleData(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btTransformDoubleData(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btTransformDoubleData position(long position) { - return (btTransformDoubleData)super.position(position); - } - @Override public btTransformDoubleData getPointer(long i) { - return new btTransformDoubleData((Pointer)this).offsetAddress(i); - } - - public native @ByRef btMatrix3x3DoubleData m_basis(); public native btTransformDoubleData m_basis(btMatrix3x3DoubleData setter); - public native @ByRef btVector3DoubleData m_origin(); public native btTransformDoubleData m_origin(btVector3DoubleData setter); -} - - - - - - - - - - - -// #endif //BT_TRANSFORM_H - - -// Parsed from LinearMath/btAlignedObjectArray.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_OBJECT_ARRAY__ -// #define BT_OBJECT_ARRAY__ - -// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE -// #include "btAlignedAllocator.h" - -/**If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW - * then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors - * You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= - * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and - * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ - -public static final int BT_USE_PLACEMENT_NEW = 1; -//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... -// #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful - -// #ifdef BT_USE_MEMCPY -// #include -// #include -// #endif //BT_USE_MEMCPY - -// #ifdef BT_USE_PLACEMENT_NEW -// #include //for placement new -// #endif //BT_USE_PLACEMENT_NEW - -/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ -@Name("btAlignedObjectArray") @NoOffset public static class btAlignedObjectArray_btVector3 extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btVector3(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btVector3(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btAlignedObjectArray_btVector3 position(long position) { - return (btAlignedObjectArray_btVector3)super.position(position); - } - @Override public btAlignedObjectArray_btVector3 getPointer(long i) { - return new btAlignedObjectArray_btVector3((Pointer)this).offsetAddress(i); - } - - public native @ByRef @Name("operator =") btAlignedObjectArray_btVector3 put(@Const @ByRef btAlignedObjectArray_btVector3 other); - public btAlignedObjectArray_btVector3() { super((Pointer)null); allocate(); } - private native void allocate(); - - /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btVector3(@Const @ByRef btAlignedObjectArray_btVector3 otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btVector3 otherArray); - - /** return the number of elements in the array */ - public native int size(); - - public native @ByRef btVector3 at(int n); - - public native @ByRef @Name("operator []") btVector3 get(int n); - - /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ - public native void clear(); - - public native void pop_back(); - - /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. - * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ - public native void resizeNoInitialize(int newsize); - - public native void resize(int newsize, @Const @ByRef(nullValue = "btVector3()") btVector3 fillData); - public native void resize(int newsize); - public native @ByRef btVector3 expandNonInitializing(); - - public native @ByRef btVector3 expand(@Const @ByRef(nullValue = "btVector3()") btVector3 fillValue); - public native @ByRef btVector3 expand(); - - public native void push_back(@Const @ByRef btVector3 _Val); - - /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ - public native @Name("capacity") int _capacity(); - - public native void reserve(int _Count); - - /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ - - public native void swap(int index0, int index1); - - /**non-recursive binary search, assumes sorted array */ - public native int findBinarySearch(@Const @ByRef btVector3 key); - - public native int findLinearSearch(@Const @ByRef btVector3 key); - - // If the key is not in the array, return -1 instead of 0, - // since 0 also means the first element in the array. - public native int findLinearSearch2(@Const @ByRef btVector3 key); - - public native void removeAtIndex(int index); - public native void remove(@Const @ByRef btVector3 key); - - //PCK: whole function - public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btVector3 otherArray); -} -@Name("btAlignedObjectArray") @NoOffset public static class btAlignedObjectArray_btScalar extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btScalar(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btScalar(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btAlignedObjectArray_btScalar position(long position) { - return (btAlignedObjectArray_btScalar)super.position(position); - } - @Override public btAlignedObjectArray_btScalar getPointer(long i) { - return new btAlignedObjectArray_btScalar((Pointer)this).offsetAddress(i); - } - - public native @ByRef @Name("operator =") btAlignedObjectArray_btScalar put(@Const @ByRef btAlignedObjectArray_btScalar other); - public btAlignedObjectArray_btScalar() { super((Pointer)null); allocate(); } - private native void allocate(); - - /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btScalar(@Const @ByRef btAlignedObjectArray_btScalar otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btScalar otherArray); - - /** return the number of elements in the array */ - public native int size(); - - public native @Cast("btScalar*") @ByRef FloatPointer at(int n); - - public native @Cast("btScalar*") @ByRef @Name("operator []") FloatPointer get(int n); - - /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ - public native void clear(); - - public native void pop_back(); - - /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. - * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ - public native void resizeNoInitialize(int newsize); - - public native void resize(int newsize, @Cast("const btScalar") float fillData/*=btScalar()*/); - public native void resize(int newsize); - public native @Cast("btScalar*") @ByRef FloatPointer expandNonInitializing(); - - public native @Cast("btScalar*") @ByRef FloatPointer expand(@Cast("const btScalar") float fillValue/*=btScalar()*/); - public native @Cast("btScalar*") @ByRef FloatPointer expand(); - - public native void push_back(@Cast("const btScalar") float _Val); - - /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ - public native @Name("capacity") int _capacity(); - - public native void reserve(int _Count); - - /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ - - public native void swap(int index0, int index1); - - /**non-recursive binary search, assumes sorted array */ - public native int findBinarySearch(@Cast("const btScalar") float key); - - public native int findLinearSearch(@Cast("const btScalar") float key); - - // If the key is not in the array, return -1 instead of 0, - // since 0 also means the first element in the array. - public native int findLinearSearch2(@Cast("const btScalar") float key); - - public native void removeAtIndex(int index); - public native void remove(@Cast("const btScalar") float key); - - //PCK: whole function - public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btScalar otherArray); -} - -// #endif //BT_OBJECT_ARRAY__ - - -// Parsed from LinearMath/btHashMap.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_HASH_MAP_H -// #define BT_HASH_MAP_H - -// #include -// #include "btAlignedObjectArray.h" - -/**very basic hashable string implementation, compatible with btHashMap */ -@NoOffset public static class btHashString extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHashString(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btHashString(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btHashString position(long position) { - return (btHashString)super.position(position); - } - @Override public btHashString getPointer(long i) { - return new btHashString((Pointer)this).offsetAddress(i); - } - - public native @StdString BytePointer m_string1(); public native btHashString m_string1(BytePointer setter); - public native @Cast("unsigned int") int m_hash(); public native btHashString m_hash(int setter); - - public native @Cast("unsigned int") int getHash(); - - public btHashString() { super((Pointer)null); allocate(); } - private native void allocate(); - public btHashString(@Cast("const char*") BytePointer name) { super((Pointer)null); allocate(name); } - private native void allocate(@Cast("const char*") BytePointer name); - public btHashString(String name) { super((Pointer)null); allocate(name); } - private native void allocate(String name); - - public native @Cast("bool") boolean equals(@Const @ByRef btHashString other); -} - -@MemberGetter public static native int BT_HASH_NULL(); - -@NoOffset public static class btHashInt extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHashInt(Pointer p) { super(p); } - - public btHashInt() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btHashInt(int uid) { super((Pointer)null); allocate(uid); } - private native void allocate(int uid); - - public native int getUid1(); - - public native void setUid1(int uid); - - public native @Cast("bool") boolean equals(@Const @ByRef btHashInt other); - //to our success - public native @Cast("unsigned int") int getHash(); -} - -public static class btHashPtr extends Pointer { - static { Loader.load(); } - - public btHashPtr(@Const Pointer ptr) { super((Pointer)null); allocate(ptr); } - private native void allocate(@Const Pointer ptr); - - public native @Const Pointer getPointer(); - - public native @Cast("bool") boolean equals(@Const @ByRef btHashPtr other); - - //to our success - public native @Cast("unsigned int") int getHash(); -} - -/**The btHashMap template class implements a generic and lightweight hashmap. - * A basic sample of how to use btHashMap is located in Demos\BasicDemo\main.cpp */ -@Name("btHashMap") public static class btHashMap_btHashPtr_voidPointer extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btHashMap_btHashPtr_voidPointer() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btHashMap_btHashPtr_voidPointer(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btHashMap_btHashPtr_voidPointer(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btHashMap_btHashPtr_voidPointer position(long position) { - return (btHashMap_btHashPtr_voidPointer)super.position(position); - } - @Override public btHashMap_btHashPtr_voidPointer getPointer(long i) { - return new btHashMap_btHashPtr_voidPointer((Pointer)this).offsetAddress(i); - } - - public native void insert(@Const @ByRef btHashPtr key, @ByPtrRef Pointer value); - - public native void remove(@Const @ByRef btHashPtr key); - - public native int size(); - - public native @Cast("void**") PointerPointer getAtIndex(int index); - - public native @ByVal btHashPtr getKeyAtIndex(int index); - - public native @Cast("void**") @Name("operator []") PointerPointer get(@Const @ByRef btHashPtr key); - - public native @Cast("void**") PointerPointer find(@Const @ByRef btHashPtr key); - - public native int findIndex(@Const @ByRef btHashPtr key); - - public native void clear(); -} - -// #endif //BT_HASH_MAP_H - - -// Parsed from LinearMath/btSerializer.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SERIALIZER_H -// #define BT_SERIALIZER_H - -// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE -// #include "btHashMap.h" - -// #if !defined(__CELLOS_LV2__) && !defined(__MWERKS__) -// #include -// #endif -// #include - -public static native @Cast("char") byte sBulletDNAstr(int i); public static native void sBulletDNAstr(int i, byte setter); -@MemberGetter public static native @Cast("char*") BytePointer sBulletDNAstr(); -public static native int sBulletDNAlen(); public static native void sBulletDNAlen(int setter); -public static native @Cast("char") byte sBulletDNAstr64(int i); public static native void sBulletDNAstr64(int i, byte setter); -@MemberGetter public static native @Cast("char*") BytePointer sBulletDNAstr64(); -public static native int sBulletDNAlen64(); public static native void sBulletDNAlen64(int setter); - -public static native int btStrLen(@Cast("const char*") BytePointer str); -public static native int btStrLen(String str); - -public static class btChunk extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btChunk() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btChunk(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btChunk(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btChunk position(long position) { - return (btChunk)super.position(position); - } - @Override public btChunk getPointer(long i) { - return new btChunk((Pointer)this).offsetAddress(i); - } - - public native int m_chunkCode(); public native btChunk m_chunkCode(int setter); - public native int m_length(); public native btChunk m_length(int setter); - public native Pointer m_oldPtr(); public native btChunk m_oldPtr(Pointer setter); - public native int m_dna_nr(); public native btChunk m_dna_nr(int setter); - public native int m_number(); public native btChunk m_number(int setter); -} - -/** enum btSerializationFlags */ -public static final int - BT_SERIALIZE_NO_BVH = 1, - BT_SERIALIZE_NO_TRIANGLEINFOMAP = 2, - BT_SERIALIZE_NO_DUPLICATE_ASSERT = 4, - BT_SERIALIZE_CONTACT_MANIFOLDS = 8; - -public static class btSerializer extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSerializer(Pointer p) { super(p); } - - - public native @Cast("const unsigned char*") BytePointer getBufferPointer(); - - public native int getCurrentBufferSize(); - - public native @Name("allocate") btChunk _allocate(@Cast("size_t") long size, int numElements); - - public native void finalizeChunk(btChunk chunk, @Cast("const char*") BytePointer structType, int chunkCode, Pointer oldPtr); - public native void finalizeChunk(btChunk chunk, String structType, int chunkCode, Pointer oldPtr); - - public native Pointer findPointer(Pointer oldPtr); - - public native Pointer getUniquePointer(Pointer oldPtr); - - public native void startSerialization(); - - public native void finishSerialization(); - - public native @Cast("const char*") BytePointer findNameForPointer(@Const Pointer ptr); - - public native void registerNameForPointer(@Const Pointer ptr, @Cast("const char*") BytePointer name); - public native void registerNameForPointer(@Const Pointer ptr, String name); - - public native void serializeName(@Cast("const char*") BytePointer ptr); - public native void serializeName(String ptr); - - public native int getSerializationFlags(); - - public native void setSerializationFlags(int flags); - - public native int getNumChunks(); - - public native @Const btChunk getChunk(int chunkIndex); -} - -public static final int BT_HEADER_LENGTH = 12; -// #if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__) -// #define BT_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d)) -// #else -// #define BT_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a)) -// #endif - -public static native @MemberGetter int BT_MULTIBODY_CODE(); -public static final int BT_MULTIBODY_CODE = BT_MULTIBODY_CODE(); -public static native @MemberGetter int BT_MB_LINKCOLLIDER_CODE(); -public static final int BT_MB_LINKCOLLIDER_CODE = BT_MB_LINKCOLLIDER_CODE(); -public static native @MemberGetter int BT_SOFTBODY_CODE(); -public static final int BT_SOFTBODY_CODE = BT_SOFTBODY_CODE(); -public static native @MemberGetter int BT_COLLISIONOBJECT_CODE(); -public static final int BT_COLLISIONOBJECT_CODE = BT_COLLISIONOBJECT_CODE(); -public static native @MemberGetter int BT_RIGIDBODY_CODE(); -public static final int BT_RIGIDBODY_CODE = BT_RIGIDBODY_CODE(); -public static native @MemberGetter int BT_CONSTRAINT_CODE(); -public static final int BT_CONSTRAINT_CODE = BT_CONSTRAINT_CODE(); -public static native @MemberGetter int BT_BOXSHAPE_CODE(); -public static final int BT_BOXSHAPE_CODE = BT_BOXSHAPE_CODE(); -public static native @MemberGetter int BT_QUANTIZED_BVH_CODE(); -public static final int BT_QUANTIZED_BVH_CODE = BT_QUANTIZED_BVH_CODE(); -public static native @MemberGetter int BT_TRIANLGE_INFO_MAP(); -public static final int BT_TRIANLGE_INFO_MAP = BT_TRIANLGE_INFO_MAP(); -public static native @MemberGetter int BT_SHAPE_CODE(); -public static final int BT_SHAPE_CODE = BT_SHAPE_CODE(); -public static native @MemberGetter int BT_ARRAY_CODE(); -public static final int BT_ARRAY_CODE = BT_ARRAY_CODE(); -public static native @MemberGetter int BT_SBMATERIAL_CODE(); -public static final int BT_SBMATERIAL_CODE = BT_SBMATERIAL_CODE(); -public static native @MemberGetter int BT_SBNODE_CODE(); -public static final int BT_SBNODE_CODE = BT_SBNODE_CODE(); -public static native @MemberGetter int BT_DYNAMICSWORLD_CODE(); -public static final int BT_DYNAMICSWORLD_CODE = BT_DYNAMICSWORLD_CODE(); -public static native @MemberGetter int BT_CONTACTMANIFOLD_CODE(); -public static final int BT_CONTACTMANIFOLD_CODE = BT_CONTACTMANIFOLD_CODE(); -public static native @MemberGetter int BT_DNA_CODE(); -public static final int BT_DNA_CODE = BT_DNA_CODE(); - -public static class btPointerUid extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btPointerUid() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btPointerUid(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPointerUid(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btPointerUid position(long position) { - return (btPointerUid)super.position(position); - } - @Override public btPointerUid getPointer(long i) { - return new btPointerUid((Pointer)this).offsetAddress(i); - } - - public native Pointer m_ptr(); public native btPointerUid m_ptr(Pointer setter); - public native int m_uniqueIds(int i); public native btPointerUid m_uniqueIds(int i, int setter); - @MemberGetter public native IntPointer m_uniqueIds(); -} - -/**The btDefaultSerializer is the main Bullet serialization class. - * The constructor takes an optional argument for backwards compatibility, it is recommended to leave this empty/zero. */ -@NoOffset public static class btDefaultSerializer extends btSerializer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDefaultSerializer(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btDefaultSerializer(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btDefaultSerializer position(long position) { - return (btDefaultSerializer)super.position(position); - } - @Override public btDefaultSerializer getPointer(long i) { - return new btDefaultSerializer((Pointer)this).offsetAddress(i); - } - - @MemberGetter public native @ByRef btHashMap_btHashPtr_voidPointer m_skipPointers(); - - public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") BytePointer buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } - private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") BytePointer buffer/*=0*/); - public btDefaultSerializer() { super((Pointer)null); allocate(); } - private native void allocate(); - public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") ByteBuffer buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } - private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") ByteBuffer buffer/*=0*/); - public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") byte[] buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } - private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") byte[] buffer/*=0*/); - - public static native int getMemoryDnaSizeInBytes(); - public static native @Cast("const char*") BytePointer getMemoryDna(); - - public native void insertHeader(); - - public native void writeHeader(@Cast("unsigned char*") BytePointer buffer); - public native void writeHeader(@Cast("unsigned char*") ByteBuffer buffer); - public native void writeHeader(@Cast("unsigned char*") byte[] buffer); - - public native void startSerialization(); - - public native void finishSerialization(); - - public native Pointer getUniquePointer(Pointer oldPtr); - - public native @Cast("const unsigned char*") BytePointer getBufferPointer(); - - public native int getCurrentBufferSize(); - - public native void finalizeChunk(btChunk chunk, @Cast("const char*") BytePointer structType, int chunkCode, Pointer oldPtr); - public native void finalizeChunk(btChunk chunk, String structType, int chunkCode, Pointer oldPtr); - - public native @Cast("unsigned char*") BytePointer internalAlloc(@Cast("size_t") long size); - - public native @Name("allocate") btChunk _allocate(@Cast("size_t") long size, int numElements); - - public native @Cast("const char*") BytePointer findNameForPointer(@Const Pointer ptr); - - public native void registerNameForPointer(@Const Pointer ptr, @Cast("const char*") BytePointer name); - public native void registerNameForPointer(@Const Pointer ptr, String name); - - public native void serializeName(@Cast("const char*") BytePointer name); - public native void serializeName(String name); - - public native int getSerializationFlags(); - - public native void setSerializationFlags(int flags); - public native int getNumChunks(); - - public native @Const btChunk getChunk(int chunkIndex); -} - -/**In general it is best to use btDefaultSerializer, - * in particular when writing the data to disk or sending it over the network. - * The btInMemorySerializer is experimental and only suitable in a few cases. - * The btInMemorySerializer takes a shortcut and can be useful to create a deep-copy - * of objects. There will be a demo on how to use the btInMemorySerializer. */ -// #ifdef ENABLE_INMEMORY_SERIALIZER -// #endif //ENABLE_INMEMORY_SERIALIZER - -// #endif //BT_SERIALIZER_H - - -// Parsed from LinearMath/btIDebugDraw.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_IDEBUG_DRAW__H -// #define BT_IDEBUG_DRAW__H - -// #include "btVector3.h" -// #include "btTransform.h" - -/**The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations. - * Typical use case: create a debug drawer object, and assign it to a btCollisionWorld or btDynamicsWorld using setDebugDrawer and call debugDrawWorld. - * A class that implements the btIDebugDraw interface will need to provide non-empty implementations of the the drawLine and getDebugMode methods at a minimum. - * For color arguments the X,Y,Z components refer to Red, Green and Blue each in the range [0..1] */ -public static class btIDebugDraw extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btIDebugDraw(Pointer p) { super(p); } - - @NoOffset public static class DefaultColors extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public DefaultColors(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public DefaultColors(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public DefaultColors position(long position) { - return (DefaultColors)super.position(position); - } - @Override public DefaultColors getPointer(long i) { - return new DefaultColors((Pointer)this).offsetAddress(i); - } - - public native @ByRef btVector3 m_activeObject(); public native DefaultColors m_activeObject(btVector3 setter); - public native @ByRef btVector3 m_deactivatedObject(); public native DefaultColors m_deactivatedObject(btVector3 setter); - public native @ByRef btVector3 m_wantsDeactivationObject(); public native DefaultColors m_wantsDeactivationObject(btVector3 setter); - public native @ByRef btVector3 m_disabledDeactivationObject(); public native DefaultColors m_disabledDeactivationObject(btVector3 setter); - public native @ByRef btVector3 m_disabledSimulationObject(); public native DefaultColors m_disabledSimulationObject(btVector3 setter); - public native @ByRef btVector3 m_aabb(); public native DefaultColors m_aabb(btVector3 setter); - public native @ByRef btVector3 m_contactPoint(); public native DefaultColors m_contactPoint(btVector3 setter); - - public DefaultColors() { super((Pointer)null); allocate(); } - private native void allocate(); - } - - /** enum btIDebugDraw::DebugDrawModes */ - public static final int - DBG_NoDebug = 0, - DBG_DrawWireframe = 1, - DBG_DrawAabb = 2, - DBG_DrawFeaturesText = 4, - DBG_DrawContactPoints = 8, - DBG_NoDeactivation = 16, - DBG_NoHelpText = 32, - DBG_DrawText = 64, - DBG_ProfileTimings = 128, - DBG_EnableSatComparison = 256, - DBG_DisableBulletLCP = 512, - DBG_EnableCCD = 1024, - DBG_DrawConstraints = (1 << 11), - DBG_DrawConstraintLimits = (1 << 12), - DBG_FastWireframe = (1 << 13), - DBG_DrawNormals = (1 << 14), - DBG_DrawFrames = (1 << 15), - DBG_MAX_DEBUG_DRAW_MODE = (1 << 15) + 1; - - public native @ByVal DefaultColors getDefaultColors(); - /**the default implementation for setDefaultColors has no effect. A derived class can implement it and store the colors. */ - public native void setDefaultColors(@Const @ByRef DefaultColors arg0); - - public native void drawLine(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 color); - - public native void drawLine(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 fromColor, @Const @ByRef btVector3 toColor); - - public native void drawSphere(@Cast("btScalar") float radius, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); - - public native void drawSphere(@Const @ByRef btVector3 p, @Cast("btScalar") float radius, @Const @ByRef btVector3 color); - - public native void drawTriangle(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 arg3, @Const @ByRef btVector3 arg4, @Const @ByRef btVector3 arg5, @Const @ByRef btVector3 color, @Cast("btScalar") float alpha); - public native void drawTriangle(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 color, @Cast("btScalar") float arg4); - - public native void drawContactPoint(@Const @ByRef btVector3 PointOnB, @Const @ByRef btVector3 normalOnB, @Cast("btScalar") float distance, int lifeTime, @Const @ByRef btVector3 color); - - public native void reportErrorWarning(@Cast("const char*") BytePointer warningString); - public native void reportErrorWarning(String warningString); - - public native void draw3dText(@Const @ByRef btVector3 location, @Cast("const char*") BytePointer textString); - public native void draw3dText(@Const @ByRef btVector3 location, String textString); - - public native void setDebugMode(int debugMode); - - public native int getDebugMode(); - - public native void drawAabb(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 color); - public native void drawTransform(@Const @ByRef btTransform transform, @Cast("btScalar") float orthoLen); - - public native void drawArc(@Const @ByRef btVector3 center, @Const @ByRef btVector3 normal, @Const @ByRef btVector3 axis, @Cast("btScalar") float radiusA, @Cast("btScalar") float radiusB, @Cast("btScalar") float minAngle, @Cast("btScalar") float maxAngle, - @Const @ByRef btVector3 color, @Cast("bool") boolean drawSect, @Cast("btScalar") float stepDegrees/*=btScalar(10.f)*/); - public native void drawArc(@Const @ByRef btVector3 center, @Const @ByRef btVector3 normal, @Const @ByRef btVector3 axis, @Cast("btScalar") float radiusA, @Cast("btScalar") float radiusB, @Cast("btScalar") float minAngle, @Cast("btScalar") float maxAngle, - @Const @ByRef btVector3 color, @Cast("bool") boolean drawSect); - public native void drawSpherePatch(@Const @ByRef btVector3 center, @Const @ByRef btVector3 up, @Const @ByRef btVector3 axis, @Cast("btScalar") float radius, - @Cast("btScalar") float minTh, @Cast("btScalar") float maxTh, @Cast("btScalar") float minPs, @Cast("btScalar") float maxPs, @Const @ByRef btVector3 color, @Cast("btScalar") float stepDegrees/*=btScalar(10.f)*/, @Cast("bool") boolean drawCenter/*=true*/); - public native void drawSpherePatch(@Const @ByRef btVector3 center, @Const @ByRef btVector3 up, @Const @ByRef btVector3 axis, @Cast("btScalar") float radius, - @Cast("btScalar") float minTh, @Cast("btScalar") float maxTh, @Cast("btScalar") float minPs, @Cast("btScalar") float maxPs, @Const @ByRef btVector3 color); - - public native void drawBox(@Const @ByRef btVector3 bbMin, @Const @ByRef btVector3 bbMax, @Const @ByRef btVector3 color); - public native void drawBox(@Const @ByRef btVector3 bbMin, @Const @ByRef btVector3 bbMax, @Const @ByRef btTransform trans, @Const @ByRef btVector3 color); - - public native void drawCapsule(@Cast("btScalar") float radius, @Cast("btScalar") float halfHeight, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); - - public native void drawCylinder(@Cast("btScalar") float radius, @Cast("btScalar") float halfHeight, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); - - public native void drawCone(@Cast("btScalar") float radius, @Cast("btScalar") float height, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); - - public native void drawPlane(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConst, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); - - public native void clearLines(); - - public native void flushLines(); -} - -// #endif //BT_IDEBUG_DRAW__H - - -// Parsed from LinearMath/btQuickprof.h - - -/*************************************************************************************************** -** -** Real-Time Hierarchical Profiling for Game Programming Gems 3 -** -** by Greg Hjelstrom & Byon Garrabrant -** -***************************************************************************************************/ - -// Credits: The Clock class was inspired by the Timer classes in -// Ogre (www.ogre3d.org). - -// #ifndef BT_QUICK_PROF_H -// #define BT_QUICK_PROF_H - -// #include "btScalar.h" -public static final int USE_BT_CLOCK = 1; - -// #ifdef USE_BT_CLOCK - -/**The btClock is a portable basic clock that measures accurate time in seconds, use for profiling. */ -@NoOffset public static class btClock extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btClock(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btClock(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btClock position(long position) { - return (btClock)super.position(position); - } - @Override public btClock getPointer(long i) { - return new btClock((Pointer)this).offsetAddress(i); - } - - public btClock() { super((Pointer)null); allocate(); } - private native void allocate(); - - public btClock(@Const @ByRef btClock other) { super((Pointer)null); allocate(other); } - private native void allocate(@Const @ByRef btClock other); - public native @ByRef @Name("operator =") btClock put(@Const @ByRef btClock other); - - /** Resets the initial reference time. */ - public native void reset(); - - /** Returns the time in ms since the last call to reset or since - * the btClock was created. */ - public native @Cast("unsigned long long int") long getTimeMilliseconds(); - - /** Returns the time in us since the last call to reset or since - * the Clock was created. */ - public native @Cast("unsigned long long int") long getTimeMicroseconds(); - - public native @Cast("unsigned long long int") long getTimeNanoseconds(); - - /** Returns the time in s since the last call to reset or since - * the Clock was created. */ - public native @Cast("btScalar") float getTimeSeconds(); -} - -// #endif //USE_BT_CLOCK - -public static class btEnterProfileZoneFunc extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btEnterProfileZoneFunc(Pointer p) { super(p); } - protected btEnterProfileZoneFunc() { allocate(); } - private native void allocate(); - public native void call(@Cast("const char*") BytePointer msg); -} -public static class btLeaveProfileZoneFunc extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btLeaveProfileZoneFunc(Pointer p) { super(p); } - protected btLeaveProfileZoneFunc() { allocate(); } - private native void allocate(); - public native void call(); -} - -public static native btEnterProfileZoneFunc btGetCurrentEnterProfileZoneFunc(); -public static native btLeaveProfileZoneFunc btGetCurrentLeaveProfileZoneFunc(); - -public static native void btSetCustomEnterProfileZoneFunc(btEnterProfileZoneFunc enterFunc); -public static native void btSetCustomLeaveProfileZoneFunc(btLeaveProfileZoneFunc leaveFunc); - -// #ifndef BT_ENABLE_PROFILE -public static final int BT_NO_PROFILE = 1; -// #endif //BT_NO_PROFILE - -@MemberGetter public static native @Cast("const unsigned int") int BT_QUICKPROF_MAX_THREAD_COUNT(); - -//btQuickprofGetCurrentThreadIndex will return -1 if thread index cannot be determined, -//otherwise returns thread index in range [0..maxThreads] -public static native @Cast("unsigned int") int btQuickprofGetCurrentThreadIndex2(); - -// #ifndef BT_NO_PROFILE - -// #endif //#ifndef BT_NO_PROFILE - -/**ProfileSampleClass is a simple way to profile a function's scope - * Use the BT_PROFILE macro at the start of scope to time */ -public static class CProfileSample extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public CProfileSample(Pointer p) { super(p); } - - public CProfileSample(@Cast("const char*") BytePointer name) { super((Pointer)null); allocate(name); } - private native void allocate(@Cast("const char*") BytePointer name); - public CProfileSample(String name) { super((Pointer)null); allocate(name); } - private native void allocate(String name); -} - -// #define BT_PROFILE(name) CProfileSample __profile(name) - -// #endif //BT_QUICK_PROF_H - - -// Parsed from LinearMath/btMotionState.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_MOTIONSTATE_H -// #define BT_MOTIONSTATE_H - -// #include "btTransform.h" - -/**The btMotionState interface class allows the dynamics world to synchronize and interpolate the updated world transforms with graphics - * For optimizations, potentially only moving objects get synchronized (using setWorldPosition/setWorldOrientation) */ -public static class btMotionState extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btMotionState(Pointer p) { super(p); } - - - public native void getWorldTransform(@ByRef btTransform worldTrans); - - //Bullet only calls the update of worldtransform for active objects - public native void setWorldTransform(@Const @ByRef btTransform worldTrans); -} - -// #endif //BT_MOTIONSTATE_H - - -// Parsed from LinearMath/btDefaultMotionState.h - -// #ifndef BT_DEFAULT_MOTION_STATE_H -// #define BT_DEFAULT_MOTION_STATE_H - -// #include "btMotionState.h" - -/**The btDefaultMotionState provides a common implementation to synchronize world transforms with offsets. */ -@NoOffset public static class btDefaultMotionState extends btMotionState { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btDefaultMotionState(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btDefaultMotionState(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public btDefaultMotionState position(long position) { - return (btDefaultMotionState)super.position(position); - } - @Override public btDefaultMotionState getPointer(long i) { - return new btDefaultMotionState((Pointer)this).offsetAddress(i); - } - - public native @ByRef btTransform m_graphicsWorldTrans(); public native btDefaultMotionState m_graphicsWorldTrans(btTransform setter); - public native @ByRef btTransform m_centerOfMassOffset(); public native btDefaultMotionState m_centerOfMassOffset(btTransform setter); - public native @ByRef btTransform m_startWorldTrans(); public native btDefaultMotionState m_startWorldTrans(btTransform setter); - public native Pointer m_userPointer(); public native btDefaultMotionState m_userPointer(Pointer setter); - - public btDefaultMotionState(@Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform startTrans, @Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform centerOfMassOffset) { super((Pointer)null); allocate(startTrans, centerOfMassOffset); } - private native void allocate(@Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform startTrans, @Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform centerOfMassOffset); - public btDefaultMotionState() { super((Pointer)null); allocate(); } - private native void allocate(); - - /**synchronizes world transform from user to physics */ - public native void getWorldTransform(@ByRef btTransform centerOfMassWorldTrans); - - /**synchronizes world transform from physics to user - * Bullet only calls the update of worldtransform for active objects */ - public native void setWorldTransform(@Const @ByRef btTransform centerOfMassWorldTrans); -} - -// #endif //BT_DEFAULT_MOTION_STATE_H - - -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java new file mode 100644 index 00000000000..6a6744d215c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java @@ -0,0 +1,30 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +// #ifndef BT_NO_PROFILE + +// #endif //#ifndef BT_NO_PROFILE + +/**ProfileSampleClass is a simple way to profile a function's scope + * Use the BT_PROFILE macro at the start of scope to time */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class CProfileSample extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CProfileSample(Pointer p) { super(p); } + + public CProfileSample(@Cast("const char*") BytePointer name) { super((Pointer)null); allocate(name); } + private native void allocate(@Cast("const char*") BytePointer name); + public CProfileSample(String name) { super((Pointer)null); allocate(name); } + private native void allocate(String name); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java new file mode 100644 index 00000000000..4ecdd43697b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedObjectArray_btScalar extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btScalar(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btScalar(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btScalar position(long position) { + return (btAlignedObjectArray_btScalar)super.position(position); + } + @Override public btAlignedObjectArray_btScalar getPointer(long i) { + return new btAlignedObjectArray_btScalar((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btScalar put(@Const @ByRef btAlignedObjectArray_btScalar other); + public btAlignedObjectArray_btScalar() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btScalar(@Const @ByRef btAlignedObjectArray_btScalar otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btScalar otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @Cast("btScalar*") @ByRef FloatPointer at(int n); + + public native @Cast("btScalar*") @ByRef @Name("operator []") FloatPointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Cast("const btScalar") float fillData/*=btScalar()*/); + public native void resize(int newsize); + public native @Cast("btScalar*") @ByRef FloatPointer expandNonInitializing(); + + public native @Cast("btScalar*") @ByRef FloatPointer expand(@Cast("const btScalar") float fillValue/*=btScalar()*/); + public native @Cast("btScalar*") @ByRef FloatPointer expand(); + + public native void push_back(@Cast("const btScalar") float _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Cast("const btScalar") float key); + + public native int findLinearSearch(@Cast("const btScalar") float key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Cast("const btScalar") float key); + + public native void removeAtIndex(int index); + public native void remove(@Cast("const btScalar") float key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btScalar otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java new file mode 100644 index 00000000000..18423f897ca --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedObjectArray_btVector3 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btVector3(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btVector3(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btVector3 position(long position) { + return (btAlignedObjectArray_btVector3)super.position(position); + } + @Override public btAlignedObjectArray_btVector3 getPointer(long i) { + return new btAlignedObjectArray_btVector3((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btVector3 put(@Const @ByRef btAlignedObjectArray_btVector3 other); + public btAlignedObjectArray_btVector3() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btVector3(@Const @ByRef btAlignedObjectArray_btVector3 otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btVector3 otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btVector3 at(int n); + + public native @ByRef @Name("operator []") btVector3 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btVector3()") btVector3 fillData); + public native void resize(int newsize); + public native @ByRef btVector3 expandNonInitializing(); + + public native @ByRef btVector3 expand(@Const @ByRef(nullValue = "btVector3()") btVector3 fillValue); + public native @ByRef btVector3 expand(); + + public native void push_back(@Const @ByRef btVector3 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Const @ByRef btVector3 key); + + public native int findLinearSearch(@Const @ByRef btVector3 key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Const @ByRef btVector3 key); + + public native void removeAtIndex(int index); + public native void remove(@Const @ByRef btVector3 key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btVector3 otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java new file mode 100644 index 00000000000..100f7d3e2ff --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btChunk extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btChunk() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btChunk(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btChunk(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btChunk position(long position) { + return (btChunk)super.position(position); + } + @Override public btChunk getPointer(long i) { + return new btChunk((Pointer)this).offsetAddress(i); + } + + public native int m_chunkCode(); public native btChunk m_chunkCode(int setter); + public native int m_length(); public native btChunk m_length(int setter); + public native Pointer m_oldPtr(); public native btChunk m_oldPtr(Pointer setter); + public native int m_dna_nr(); public native btChunk m_dna_nr(int setter); + public native int m_number(); public native btChunk m_number(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java new file mode 100644 index 00000000000..8e1c57f933d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java @@ -0,0 +1,55 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +// #ifdef USE_BT_CLOCK + +/**The btClock is a portable basic clock that measures accurate time in seconds, use for profiling. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btClock extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btClock(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btClock(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btClock position(long position) { + return (btClock)super.position(position); + } + @Override public btClock getPointer(long i) { + return new btClock((Pointer)this).offsetAddress(i); + } + + public btClock() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btClock(@Const @ByRef btClock other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btClock other); + public native @ByRef @Name("operator =") btClock put(@Const @ByRef btClock other); + + /** Resets the initial reference time. */ + public native void reset(); + + /** Returns the time in ms since the last call to reset or since + * the btClock was created. */ + public native @Cast("unsigned long long int") long getTimeMilliseconds(); + + /** Returns the time in us since the last call to reset or since + * the Clock was created. */ + public native @Cast("unsigned long long int") long getTimeMicroseconds(); + + public native @Cast("unsigned long long int") long getTimeNanoseconds(); + + /** Returns the time in s since the last call to reset or since + * the Clock was created. */ + public native @Cast("btScalar") float getTimeSeconds(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultMotionState.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultMotionState.java new file mode 100644 index 00000000000..ef1b764476e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultMotionState.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btDefaultMotionState provides a common implementation to synchronize world transforms with offsets. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btDefaultMotionState extends btMotionState { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultMotionState(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultMotionState(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultMotionState position(long position) { + return (btDefaultMotionState)super.position(position); + } + @Override public btDefaultMotionState getPointer(long i) { + return new btDefaultMotionState((Pointer)this).offsetAddress(i); + } + + public native @ByRef btTransform m_graphicsWorldTrans(); public native btDefaultMotionState m_graphicsWorldTrans(btTransform setter); + public native @ByRef btTransform m_centerOfMassOffset(); public native btDefaultMotionState m_centerOfMassOffset(btTransform setter); + public native @ByRef btTransform m_startWorldTrans(); public native btDefaultMotionState m_startWorldTrans(btTransform setter); + public native Pointer m_userPointer(); public native btDefaultMotionState m_userPointer(Pointer setter); + + public btDefaultMotionState(@Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform startTrans, @Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform centerOfMassOffset) { super((Pointer)null); allocate(startTrans, centerOfMassOffset); } + private native void allocate(@Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform startTrans, @Const @ByRef(nullValue = "btTransform::getIdentity()") btTransform centerOfMassOffset); + public btDefaultMotionState() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**synchronizes world transform from user to physics */ + public native void getWorldTransform(@ByRef btTransform centerOfMassWorldTrans); + + /**synchronizes world transform from physics to user + * Bullet only calls the update of worldtransform for active objects */ + public native void setWorldTransform(@Const @ByRef btTransform centerOfMassWorldTrans); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultSerializer.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultSerializer.java new file mode 100644 index 00000000000..1af91e5ab92 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultSerializer.java @@ -0,0 +1,82 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btDefaultSerializer is the main Bullet serialization class. + * The constructor takes an optional argument for backwards compatibility, it is recommended to leave this empty/zero. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btDefaultSerializer extends btSerializer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultSerializer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultSerializer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultSerializer position(long position) { + return (btDefaultSerializer)super.position(position); + } + @Override public btDefaultSerializer getPointer(long i) { + return new btDefaultSerializer((Pointer)this).offsetAddress(i); + } + + @MemberGetter public native @ByRef btHashMap_btHashPtr_voidPointer m_skipPointers(); + + public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") BytePointer buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } + private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") BytePointer buffer/*=0*/); + public btDefaultSerializer() { super((Pointer)null); allocate(); } + private native void allocate(); + public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") ByteBuffer buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } + private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") ByteBuffer buffer/*=0*/); + public btDefaultSerializer(int totalSize/*=0*/, @Cast("unsigned char*") byte[] buffer/*=0*/) { super((Pointer)null); allocate(totalSize, buffer); } + private native void allocate(int totalSize/*=0*/, @Cast("unsigned char*") byte[] buffer/*=0*/); + + public static native int getMemoryDnaSizeInBytes(); + public static native @Cast("const char*") BytePointer getMemoryDna(); + + public native void insertHeader(); + + public native void writeHeader(@Cast("unsigned char*") BytePointer buffer); + public native void writeHeader(@Cast("unsigned char*") ByteBuffer buffer); + public native void writeHeader(@Cast("unsigned char*") byte[] buffer); + + public native void startSerialization(); + + public native void finishSerialization(); + + public native Pointer getUniquePointer(Pointer oldPtr); + + public native @Cast("const unsigned char*") BytePointer getBufferPointer(); + + public native int getCurrentBufferSize(); + + public native void finalizeChunk(btChunk chunk, @Cast("const char*") BytePointer structType, int chunkCode, Pointer oldPtr); + public native void finalizeChunk(btChunk chunk, String structType, int chunkCode, Pointer oldPtr); + + public native @Cast("unsigned char*") BytePointer internalAlloc(@Cast("size_t") long size); + + public native @Name("allocate") btChunk _allocate(@Cast("size_t") long size, int numElements); + + public native @Cast("const char*") BytePointer findNameForPointer(@Const Pointer ptr); + + public native void registerNameForPointer(@Const Pointer ptr, @Cast("const char*") BytePointer name); + public native void registerNameForPointer(@Const Pointer ptr, String name); + + public native void serializeName(@Cast("const char*") BytePointer name); + public native void serializeName(String name); + + public native int getSerializationFlags(); + + public native void setSerializationFlags(int flags); + public native int getNumChunks(); + + public native @Const btChunk getChunk(int chunkIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java new file mode 100644 index 00000000000..989e0e8685d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +// #endif //USE_BT_CLOCK + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btEnterProfileZoneFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btEnterProfileZoneFunc(Pointer p) { super(p); } + protected btEnterProfileZoneFunc() { allocate(); } + private native void allocate(); + public native void call(@Cast("const char*") BytePointer msg); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java new file mode 100644 index 00000000000..45926a77d77 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java @@ -0,0 +1,33 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btHashInt extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashInt(Pointer p) { super(p); } + + public btHashInt() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btHashInt(int uid) { super((Pointer)null); allocate(uid); } + private native void allocate(int uid); + + public native int getUid1(); + + public native void setUid1(int uid); + + public native @Cast("bool") boolean equals(@Const @ByRef btHashInt other); + //to our success + public native @Cast("unsigned int") int getHash(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java new file mode 100644 index 00000000000..3c5a723991b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btHashMap template class implements a generic and lightweight hashmap. + * A basic sample of how to use btHashMap is located in Demos\BasicDemo\main.cpp */ +@Name("btHashMap") @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btHashMap_btHashPtr_voidPointer extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHashMap_btHashPtr_voidPointer() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHashMap_btHashPtr_voidPointer(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashMap_btHashPtr_voidPointer(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHashMap_btHashPtr_voidPointer position(long position) { + return (btHashMap_btHashPtr_voidPointer)super.position(position); + } + @Override public btHashMap_btHashPtr_voidPointer getPointer(long i) { + return new btHashMap_btHashPtr_voidPointer((Pointer)this).offsetAddress(i); + } + + public native void insert(@Const @ByRef btHashPtr key, @ByPtrRef Pointer value); + + public native void remove(@Const @ByRef btHashPtr key); + + public native int size(); + + public native @Cast("void**") PointerPointer getAtIndex(int index); + + public native @ByVal btHashPtr getKeyAtIndex(int index); + + public native @Cast("void**") @Name("operator []") PointerPointer get(@Const @ByRef btHashPtr key); + + public native @Cast("void**") PointerPointer find(@Const @ByRef btHashPtr key); + + public native int findIndex(@Const @ByRef btHashPtr key); + + public native void clear(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java new file mode 100644 index 00000000000..5286d2c2b2f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btHashPtr extends Pointer { + static { Loader.load(); } + + public btHashPtr(@Const Pointer ptr) { super((Pointer)null); allocate(ptr); } + private native void allocate(@Const Pointer ptr); + + public native @Const Pointer getPointer(); + + public native @Cast("bool") boolean equals(@Const @ByRef btHashPtr other); + + //to our success + public native @Cast("unsigned int") int getHash(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashString.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashString.java new file mode 100644 index 00000000000..72a53b10b86 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashString.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**very basic hashable string implementation, compatible with btHashMap */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btHashString extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashString(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHashString(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btHashString position(long position) { + return (btHashString)super.position(position); + } + @Override public btHashString getPointer(long i) { + return new btHashString((Pointer)this).offsetAddress(i); + } + + public native @StdString BytePointer m_string1(); public native btHashString m_string1(BytePointer setter); + public native @Cast("unsigned int") int m_hash(); public native btHashString m_hash(int setter); + + public native @Cast("unsigned int") int getHash(); + + public btHashString() { super((Pointer)null); allocate(); } + private native void allocate(); + public btHashString(@Cast("const char*") BytePointer name) { super((Pointer)null); allocate(name); } + private native void allocate(@Cast("const char*") BytePointer name); + public btHashString(String name) { super((Pointer)null); allocate(name); } + private native void allocate(String name); + + public native @Cast("bool") boolean equals(@Const @ByRef btHashString other); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java new file mode 100644 index 00000000000..7a753eb8f36 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java @@ -0,0 +1,124 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btIDebugDraw interface class allows hooking up a debug renderer to visually debug simulations. + * Typical use case: create a debug drawer object, and assign it to a btCollisionWorld or btDynamicsWorld using setDebugDrawer and call debugDrawWorld. + * A class that implements the btIDebugDraw interface will need to provide non-empty implementations of the the drawLine and getDebugMode methods at a minimum. + * For color arguments the X,Y,Z components refer to Red, Green and Blue each in the range [0..1] */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btIDebugDraw extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIDebugDraw(Pointer p) { super(p); } + + @NoOffset public static class DefaultColors extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DefaultColors(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DefaultColors(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public DefaultColors position(long position) { + return (DefaultColors)super.position(position); + } + @Override public DefaultColors getPointer(long i) { + return new DefaultColors((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_activeObject(); public native DefaultColors m_activeObject(btVector3 setter); + public native @ByRef btVector3 m_deactivatedObject(); public native DefaultColors m_deactivatedObject(btVector3 setter); + public native @ByRef btVector3 m_wantsDeactivationObject(); public native DefaultColors m_wantsDeactivationObject(btVector3 setter); + public native @ByRef btVector3 m_disabledDeactivationObject(); public native DefaultColors m_disabledDeactivationObject(btVector3 setter); + public native @ByRef btVector3 m_disabledSimulationObject(); public native DefaultColors m_disabledSimulationObject(btVector3 setter); + public native @ByRef btVector3 m_aabb(); public native DefaultColors m_aabb(btVector3 setter); + public native @ByRef btVector3 m_contactPoint(); public native DefaultColors m_contactPoint(btVector3 setter); + + public DefaultColors() { super((Pointer)null); allocate(); } + private native void allocate(); + } + + /** enum btIDebugDraw::DebugDrawModes */ + public static final int + DBG_NoDebug = 0, + DBG_DrawWireframe = 1, + DBG_DrawAabb = 2, + DBG_DrawFeaturesText = 4, + DBG_DrawContactPoints = 8, + DBG_NoDeactivation = 16, + DBG_NoHelpText = 32, + DBG_DrawText = 64, + DBG_ProfileTimings = 128, + DBG_EnableSatComparison = 256, + DBG_DisableBulletLCP = 512, + DBG_EnableCCD = 1024, + DBG_DrawConstraints = (1 << 11), + DBG_DrawConstraintLimits = (1 << 12), + DBG_FastWireframe = (1 << 13), + DBG_DrawNormals = (1 << 14), + DBG_DrawFrames = (1 << 15), + DBG_MAX_DEBUG_DRAW_MODE = (1 << 15) + 1; + + public native @ByVal DefaultColors getDefaultColors(); + /**the default implementation for setDefaultColors has no effect. A derived class can implement it and store the colors. */ + public native void setDefaultColors(@Const @ByRef DefaultColors arg0); + + public native void drawLine(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 color); + + public native void drawLine(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 fromColor, @Const @ByRef btVector3 toColor); + + public native void drawSphere(@Cast("btScalar") float radius, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void drawSphere(@Const @ByRef btVector3 p, @Cast("btScalar") float radius, @Const @ByRef btVector3 color); + + public native void drawTriangle(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 arg3, @Const @ByRef btVector3 arg4, @Const @ByRef btVector3 arg5, @Const @ByRef btVector3 color, @Cast("btScalar") float alpha); + public native void drawTriangle(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 color, @Cast("btScalar") float arg4); + + public native void drawContactPoint(@Const @ByRef btVector3 PointOnB, @Const @ByRef btVector3 normalOnB, @Cast("btScalar") float distance, int lifeTime, @Const @ByRef btVector3 color); + + public native void reportErrorWarning(@Cast("const char*") BytePointer warningString); + public native void reportErrorWarning(String warningString); + + public native void draw3dText(@Const @ByRef btVector3 location, @Cast("const char*") BytePointer textString); + public native void draw3dText(@Const @ByRef btVector3 location, String textString); + + public native void setDebugMode(int debugMode); + + public native int getDebugMode(); + + public native void drawAabb(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, @Const @ByRef btVector3 color); + public native void drawTransform(@Const @ByRef btTransform transform, @Cast("btScalar") float orthoLen); + + public native void drawArc(@Const @ByRef btVector3 center, @Const @ByRef btVector3 normal, @Const @ByRef btVector3 axis, @Cast("btScalar") float radiusA, @Cast("btScalar") float radiusB, @Cast("btScalar") float minAngle, @Cast("btScalar") float maxAngle, + @Const @ByRef btVector3 color, @Cast("bool") boolean drawSect, @Cast("btScalar") float stepDegrees/*=btScalar(10.f)*/); + public native void drawArc(@Const @ByRef btVector3 center, @Const @ByRef btVector3 normal, @Const @ByRef btVector3 axis, @Cast("btScalar") float radiusA, @Cast("btScalar") float radiusB, @Cast("btScalar") float minAngle, @Cast("btScalar") float maxAngle, + @Const @ByRef btVector3 color, @Cast("bool") boolean drawSect); + public native void drawSpherePatch(@Const @ByRef btVector3 center, @Const @ByRef btVector3 up, @Const @ByRef btVector3 axis, @Cast("btScalar") float radius, + @Cast("btScalar") float minTh, @Cast("btScalar") float maxTh, @Cast("btScalar") float minPs, @Cast("btScalar") float maxPs, @Const @ByRef btVector3 color, @Cast("btScalar") float stepDegrees/*=btScalar(10.f)*/, @Cast("bool") boolean drawCenter/*=true*/); + public native void drawSpherePatch(@Const @ByRef btVector3 center, @Const @ByRef btVector3 up, @Const @ByRef btVector3 axis, @Cast("btScalar") float radius, + @Cast("btScalar") float minTh, @Cast("btScalar") float maxTh, @Cast("btScalar") float minPs, @Cast("btScalar") float maxPs, @Const @ByRef btVector3 color); + + public native void drawBox(@Const @ByRef btVector3 bbMin, @Const @ByRef btVector3 bbMax, @Const @ByRef btVector3 color); + public native void drawBox(@Const @ByRef btVector3 bbMin, @Const @ByRef btVector3 bbMax, @Const @ByRef btTransform trans, @Const @ByRef btVector3 color); + + public native void drawCapsule(@Cast("btScalar") float radius, @Cast("btScalar") float halfHeight, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void drawCylinder(@Cast("btScalar") float radius, @Cast("btScalar") float halfHeight, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void drawCone(@Cast("btScalar") float radius, @Cast("btScalar") float height, int upAxis, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void drawPlane(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConst, @Const @ByRef btTransform transform, @Const @ByRef btVector3 color); + + public native void clearLines(); + + public native void flushLines(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btInfMaskConverter.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btInfMaskConverter.java new file mode 100644 index 00000000000..d76a2641363 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btInfMaskConverter.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +// #endif + +// #ifdef BT_USE_SSE +// #endif //BT_USE_SSE + +// #if defined(BT_USE_SSE) +// #else//BT_USE_SSE + +// #ifdef BT_USE_NEON +// #else //BT_USE_NEON + +// #ifndef BT_INFINITY + @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btInfMaskConverter extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btInfMaskConverter(Pointer p) { super(p); } + + public native float mask(); public native btInfMaskConverter mask(float setter); + public native int intmask(); public native btInfMaskConverter intmask(int setter); + public btInfMaskConverter(int _mask/*=0x7F800000*/) { super((Pointer)null); allocate(_mask); } + private native void allocate(int _mask/*=0x7F800000*/); + public btInfMaskConverter() { super((Pointer)null); allocate(); } + private native void allocate(); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java new file mode 100644 index 00000000000..a084c5f5031 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btLeaveProfileZoneFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btLeaveProfileZoneFunc(Pointer p) { super(p); } + protected btLeaveProfileZoneFunc() { allocate(); } + private native void allocate(); + public native void call(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java new file mode 100644 index 00000000000..4c8bb815dd2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java @@ -0,0 +1,247 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +// #endif //BT_USE_DOUBLE_PRECISION + +/**\brief The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with btQuaternion, btTransform and btVector3. +* Make sure to only include a pure orthogonal matrix without scaling. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btMatrix3x3 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMatrix3x3(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMatrix3x3(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMatrix3x3 position(long position) { + return (btMatrix3x3)super.position(position); + } + @Override public btMatrix3x3 getPointer(long i) { + return new btMatrix3x3((Pointer)this).offsetAddress(i); + } + + /** \brief No initializaion constructor */ + public btMatrix3x3() { super((Pointer)null); allocate(); } + private native void allocate(); + + // explicit btMatrix3x3(const btScalar *m) { setFromOpenGLSubMatrix(m); } + + /**\brief Constructor from Quaternion */ + public btMatrix3x3(@Const @ByRef btQuaternion q) { super((Pointer)null); allocate(q); } + private native void allocate(@Const @ByRef btQuaternion q); + /* + template + Matrix3x3(const btScalar& yaw, const btScalar& pitch, const btScalar& roll) + { + setEulerYPR(yaw, pitch, roll); + } + */ + /** \brief Constructor with row major formatting */ + public btMatrix3x3(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, + @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, + @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz) { super((Pointer)null); allocate(xx, xy, xz, yx, yy, yz, zx, zy, zz); } + private native void allocate(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, + @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, + @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz); + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + +// #else + + /** \brief Copy constructor */ + public btMatrix3x3(@Const @ByRef btMatrix3x3 other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btMatrix3x3 other); + + /** \brief Assignment Operator */ + public native @ByRef @Name("operator =") btMatrix3x3 put(@Const @ByRef btMatrix3x3 other); + + public btMatrix3x3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2) { super((Pointer)null); allocate(v0, v1, v2); } + private native void allocate(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +// #endif + + /** \brief Get a column of the matrix as a vector + * @param i Column number 0 indexed */ + public native @ByVal btVector3 getColumn(int i); + + /** \brief Get a row of the matrix as a vector + * @param i Row number 0 indexed */ + public native @Const @ByRef btVector3 getRow(int i); + + /** \brief Get a mutable reference to a row of the matrix as a vector + * @param i Row number 0 indexed */ + public native @ByRef @Name("operator []") btVector3 get(int i); + + /** \brief Get a const reference to a row of the matrix as a vector + * @param i Row number 0 indexed */ + + /** \brief Multiply by the target matrix on the right + * @param m Rotation matrix to be applied + * Equivilant to this = this * m */ + public native @ByRef @Name("operator *=") btMatrix3x3 multiplyPut(@Const @ByRef btMatrix3x3 m); + + /** \brief Adds by the target matrix on the right + * @param m matrix to be applied + * Equivilant to this = this + m */ + public native @ByRef @Name("operator +=") btMatrix3x3 addPut(@Const @ByRef btMatrix3x3 m); + + /** \brief Substractss by the target matrix on the right + * @param m matrix to be applied + * Equivilant to this = this - m */ + public native @ByRef @Name("operator -=") btMatrix3x3 subtractPut(@Const @ByRef btMatrix3x3 m); + + /** \brief Set from the rotational part of a 4x4 OpenGL matrix + * @param m A pointer to the beginning of the array of scalars*/ + public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") FloatPointer m); + public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") FloatBuffer m); + public native void setFromOpenGLSubMatrix(@Cast("const btScalar*") float[] m); + /** \brief Set the values of the matrix explicitly (row major) + * @param xx Top left + * @param xy Top Middle + * @param xz Top Right + * @param yx Middle Left + * @param yy Middle Middle + * @param yz Middle Right + * @param zx Bottom Left + * @param zy Bottom Middle + * @param zz Bottom Right*/ + public native void setValue(@Cast("const btScalar") float xx, @Cast("const btScalar") float xy, @Cast("const btScalar") float xz, + @Cast("const btScalar") float yx, @Cast("const btScalar") float yy, @Cast("const btScalar") float yz, + @Cast("const btScalar") float zx, @Cast("const btScalar") float zy, @Cast("const btScalar") float zz); + + /** \brief Set the matrix from a quaternion + * @param q The Quaternion to match */ + public native void setRotation(@Const @ByRef btQuaternion q); + + /** \brief Set the matrix from euler angles using YPR around YXZ respectively + * @param yaw Yaw about Y axis + * @param pitch Pitch about X axis + * @param roll Roll about Z axis + */ + public native void setEulerYPR(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); + + /** \brief Set the matrix from euler angles YPR around ZYX axes + * @param eulerX Roll about X axis + * @param eulerY Pitch around Y axis + * @param eulerZ Yaw about Z axis + * + * These angles are used to produce a rotation matrix. The euler + * angles are applied in ZYX order. I.e a vector is first rotated + * about X then Y and then Z + **/ + public native void setEulerZYX(@Cast("btScalar") float eulerX, @Cast("btScalar") float eulerY, @Cast("btScalar") float eulerZ); + + /**\brief Set the matrix to the identity */ + public native void setIdentity(); + + /**\brief Set the matrix to the identity */ + public native void setZero(); + + public static native @Const @ByRef btMatrix3x3 getIdentity(); + + /**\brief Fill the rotational part of an OpenGL matrix and clear the shear/perspective + * @param m The array to be filled */ + public native void getOpenGLSubMatrix(@Cast("btScalar*") FloatPointer m); + public native void getOpenGLSubMatrix(@Cast("btScalar*") FloatBuffer m); + public native void getOpenGLSubMatrix(@Cast("btScalar*") float[] m); + + /**\brief Get the matrix represented as a quaternion + * @param q The quaternion which will be set */ + public native void getRotation(@ByRef btQuaternion q); + + /**\brief Get the matrix represented as euler angles around YXZ, roundtrip with setEulerYPR + * @param yaw Yaw around Y axis + * @param pitch Pitch around X axis + * @param roll around Z axis */ + public native void getEulerYPR(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll); + public native void getEulerYPR(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll); + public native void getEulerYPR(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll); + + /**\brief Get the matrix represented as euler angles around ZYX + * @param yaw Yaw around Z axis + * @param pitch Pitch around Y axis + * @param roll around X axis + * @param solution_number Which solution of two possible solutions ( 1 or 2) are possible values*/ + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yaw, @Cast("btScalar*") @ByRef FloatPointer pitch, @Cast("btScalar*") @ByRef FloatPointer roll); + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yaw, @Cast("btScalar*") @ByRef FloatBuffer pitch, @Cast("btScalar*") @ByRef FloatBuffer roll); + public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yaw, @Cast("btScalar*") @ByRef float[] pitch, @Cast("btScalar*") @ByRef float[] roll); + + /**\brief Create a scaled copy of the matrix + * @param s Scaling vector The elements of the vector will scale each column */ + + public native @ByVal btMatrix3x3 scaled(@Const @ByRef btVector3 s); + + /**\brief Return the determinant of the matrix */ + public native @Cast("btScalar") float determinant(); + /**\brief Return the adjoint of the matrix */ + public native @ByVal btMatrix3x3 adjoint(); + /**\brief Return the matrix with all values non negative */ + public native @ByVal btMatrix3x3 absolute(); + /**\brief Return the transpose of the matrix */ + public native @ByVal btMatrix3x3 transpose(); + /**\brief Return the inverse of the matrix */ + public native @ByVal btMatrix3x3 inverse(); + + /** Solve A * x = b, where b is a column vector. This is more efficient + * than computing the inverse in one-shot cases. + * Solve33 is from Box2d, thanks to Erin Catto, */ + public native @ByVal btVector3 solve33(@Const @ByRef btVector3 b); + + public native @ByVal btMatrix3x3 transposeTimes(@Const @ByRef btMatrix3x3 m); + public native @ByVal btMatrix3x3 timesTranspose(@Const @ByRef btMatrix3x3 m); + + public native @Cast("btScalar") float tdotx(@Const @ByRef btVector3 v); + public native @Cast("btScalar") float tdoty(@Const @ByRef btVector3 v); + public native @Cast("btScalar") float tdotz(@Const @ByRef btVector3 v); + + /**extractRotation is from "A robust method to extract the rotational part of deformations" + * See http://dl.acm.org/citation.cfm?doid=2994258.2994269 + * decomposes a matrix A in a orthogonal matrix R and a + * symmetric matrix S: + * A = R*S. + * note that R can include both rotation and scaling. */ + public native void extractRotation(@ByRef btQuaternion q, @Cast("btScalar") float tolerance/*=1.0e-9*/, int maxIter/*=100*/); + public native void extractRotation(@ByRef btQuaternion q); + + /**\brief diagonalizes this matrix by the Jacobi method. + * @param rot stores the rotation from the coordinate system in which the matrix is diagonal to the original + * coordinate system, i.e., old_this = rot * new_this * rot^T. + * @param threshold See iteration + * @param iteration The iteration stops when all off-diagonal elements are less than the threshold multiplied + * by the sum of the absolute values of the diagonal, or when maxSteps have been executed. + * + * Note that this matrix is assumed to be symmetric. + */ + public native void diagonalize(@ByRef btMatrix3x3 rot, @Cast("btScalar") float threshold, int maxSteps); + + /**\brief Calculate the matrix cofactor + * @param r1 The first row to use for calculating the cofactor + * @param c1 The first column to use for calculating the cofactor + * @param r1 The second row to use for calculating the cofactor + * @param c1 The second column to use for calculating the cofactor + * See http://en.wikipedia.org/wiki/Cofactor_(linear_algebra) for more details + */ + public native @Cast("btScalar") float cofac(int r1, int c1, int r2, int c2); + + public native void serialize(@ByRef btMatrix3x3FloatData dataOut); + + public native void serializeFloat(@ByRef btMatrix3x3FloatData dataOut); + + public native void deSerialize(@Const @ByRef btMatrix3x3FloatData dataIn); + + public native void deSerializeFloat(@Const @ByRef btMatrix3x3FloatData dataIn); + + public native void deSerializeDouble(@Const @ByRef btMatrix3x3DoubleData dataIn); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java new file mode 100644 index 00000000000..3b14b5935dc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**for serialization */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btMatrix3x3DoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMatrix3x3DoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMatrix3x3DoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMatrix3x3DoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMatrix3x3DoubleData position(long position) { + return (btMatrix3x3DoubleData)super.position(position); + } + @Override public btMatrix3x3DoubleData getPointer(long i) { + return new btMatrix3x3DoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3DoubleData m_el(int i); public native btMatrix3x3DoubleData m_el(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_el(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java new file mode 100644 index 00000000000..2a64ec59474 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**for serialization */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btMatrix3x3FloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMatrix3x3FloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMatrix3x3FloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMatrix3x3FloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMatrix3x3FloatData position(long position) { + return (btMatrix3x3FloatData)super.position(position); + } + @Override public btMatrix3x3FloatData getPointer(long i) { + return new btMatrix3x3FloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_el(int i); public native btMatrix3x3FloatData m_el(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_el(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java new file mode 100644 index 00000000000..e0f630a61fa --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btMotionState interface class allows the dynamics world to synchronize and interpolate the updated world transforms with graphics + * For optimizations, potentially only moving objects get synchronized (using setWorldPosition/setWorldOrientation) */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btMotionState extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMotionState(Pointer p) { super(p); } + + + public native void getWorldTransform(@ByRef btTransform worldTrans); + + //Bullet only calls the update of worldtransform for active objects + public native void setWorldTransform(@Const @ByRef btTransform worldTrans); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java new file mode 100644 index 00000000000..e22e16697b3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btPointerUid extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPointerUid() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPointerUid(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPointerUid(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPointerUid position(long position) { + return (btPointerUid)super.position(position); + } + @Override public btPointerUid getPointer(long i) { + return new btPointerUid((Pointer)this).offsetAddress(i); + } + + public native Pointer m_ptr(); public native btPointerUid m_ptr(Pointer setter); + public native int m_uniqueIds(int i); public native btPointerUid m_uniqueIds(int i, int setter); + @MemberGetter public native IntPointer m_uniqueIds(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java new file mode 100644 index 00000000000..63ac9029b1e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java @@ -0,0 +1,120 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +// #endif + +/**\brief The btQuadWord class is base class for btVector3 and btQuaternion. + * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword. + */ +// #ifndef USE_LIBSPE2 +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btQuadWord extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuadWord(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuadWord(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btQuadWord position(long position) { + return (btQuadWord)super.position(position); + } + @Override public btQuadWord getPointer(long i) { + return new btQuadWord((Pointer)this).offsetAddress(i); + } + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + +// #endif + + /**\brief Return the x value */ + public native @Cast("const btScalar") float getX(); + /**\brief Return the y value */ + public native @Cast("const btScalar") float getY(); + /**\brief Return the z value */ + public native @Cast("const btScalar") float getZ(); + /**\brief Set the x value */ + public native void setX(@Cast("btScalar") float _x); + /**\brief Set the y value */ + public native void setY(@Cast("btScalar") float _y); + /**\brief Set the z value */ + public native void setZ(@Cast("btScalar") float _z); + /**\brief Set the w value */ + public native void setW(@Cast("btScalar") float _w); + /**\brief Return the x value */ + public native @Cast("const btScalar") float x(); + /**\brief Return the y value */ + public native @Cast("const btScalar") float y(); + /**\brief Return the z value */ + public native @Cast("const btScalar") float z(); + /**\brief Return the w value */ + public native @Cast("const btScalar") float w(); + + //SIMD_FORCE_INLINE btScalar& operator[](int i) { return (&m_floats[0])[i]; } + //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; } + /**operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. */ + public native @Cast("btScalar*") @Name("operator btScalar*") FloatPointer asFloatPointer(); + + public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btQuadWord other); + + public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef btQuadWord other); + + /**\brief Set x,y,z and zero w + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); + + /* void getValue(btScalar *m) const + { + m[0] = m_floats[0]; + m[1] = m_floats[1]; + m[2] = m_floats[2]; + } +*/ + /**\brief Set the values + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); + /**\brief No initialization constructor */ + public btQuadWord() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**\brief Three argument constructor (zeros w) + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + public btQuadWord(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z) { super((Pointer)null); allocate(_x, _y, _z); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); + + /**\brief Initializing constructor + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public btQuadWord(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); + + /**\brief Set each element to the max of the current values and the values of another btQuadWord + * @param other The other btQuadWord to compare with + */ + public native void setMax(@Const @ByRef btQuadWord other); + /**\brief Set each element to the min of the current values and the values of another btQuadWord + * @param other The other btQuadWord to compare with + */ + public native void setMin(@Const @ByRef btQuadWord other); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java new file mode 100644 index 00000000000..c24956f76ba --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java @@ -0,0 +1,192 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +// #endif //BT_USE_DOUBLE_PRECISION + +// #ifdef BT_USE_SSE + +// #endif + +// #if defined(BT_USE_SSE) + +// #elif defined(BT_USE_NEON) + +// #endif + +/**\brief The btQuaternion implements quaternion to perform linear algebra rotations in combination with btMatrix3x3, btVector3 and btTransform. */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btQuaternion extends btQuadWord { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuaternion(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuaternion(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btQuaternion position(long position) { + return (btQuaternion)super.position(position); + } + @Override public btQuaternion getPointer(long i) { + return new btQuaternion((Pointer)this).offsetAddress(i); + } + + /**\brief No initialization constructor */ + public btQuaternion() { super((Pointer)null); allocate(); } + private native void allocate(); + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) + +// #endif + + // template + // explicit Quaternion(const btScalar *v) : Tuple4(v) {} + /**\brief Constructor from scalars */ + public btQuaternion(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); + /**\brief Axis angle Constructor + * @param axis The axis which the rotation is around + * @param angle The magnitude of the rotation around the angle (Radians) */ + public btQuaternion(@Const @ByRef btVector3 _axis, @Cast("const btScalar") float _angle) { super((Pointer)null); allocate(_axis, _angle); } + private native void allocate(@Const @ByRef btVector3 _axis, @Cast("const btScalar") float _angle); + /**\brief Constructor from Euler angles + * @param yaw Angle around Y unless BT_EULER_DEFAULT_ZYX defined then Z + * @param pitch Angle around X unless BT_EULER_DEFAULT_ZYX defined then Y + * @param roll Angle around Z unless BT_EULER_DEFAULT_ZYX defined then X */ + public btQuaternion(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll) { super((Pointer)null); allocate(yaw, pitch, roll); } + private native void allocate(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); + /**\brief Set the rotation using axis angle notation + * @param axis The axis around which to rotate + * @param angle The magnitude of the rotation in Radians */ + public native void setRotation(@Const @ByRef btVector3 axis, @Cast("const btScalar") float _angle); + /**\brief Set the quaternion using Euler angles + * @param yaw Angle around Y + * @param pitch Angle around X + * @param roll Angle around Z */ + public native void setEuler(@Cast("const btScalar") float yaw, @Cast("const btScalar") float pitch, @Cast("const btScalar") float roll); + /**\brief Set the quaternion using euler angles + * @param yaw Angle around Z + * @param pitch Angle around Y + * @param roll Angle around X */ + public native void setEulerZYX(@Cast("const btScalar") float yawZ, @Cast("const btScalar") float pitchY, @Cast("const btScalar") float rollX); + + /**\brief Get the euler angles from this quaternion + * @param yaw Angle around Z + * @param pitch Angle around Y + * @param roll Angle around X */ + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatPointer yawZ, @Cast("btScalar*") @ByRef FloatPointer pitchY, @Cast("btScalar*") @ByRef FloatPointer rollX); + public native void getEulerZYX(@Cast("btScalar*") @ByRef FloatBuffer yawZ, @Cast("btScalar*") @ByRef FloatBuffer pitchY, @Cast("btScalar*") @ByRef FloatBuffer rollX); + public native void getEulerZYX(@Cast("btScalar*") @ByRef float[] yawZ, @Cast("btScalar*") @ByRef float[] pitchY, @Cast("btScalar*") @ByRef float[] rollX); + + /**\brief Add two quaternions + * @param q The quaternion to add to this one */ + public native @ByRef @Name("operator +=") btQuaternion addPut(@Const @ByRef btQuaternion q); + + /**\brief Subtract out a quaternion + * @param q The quaternion to subtract from this one */ + public native @ByRef @Name("operator -=") btQuaternion subtractPut(@Const @ByRef btQuaternion q); + + /**\brief Scale this quaternion + * @param s The scalar to scale by */ + public native @ByRef @Name("operator *=") btQuaternion multiplyPut(@Cast("const btScalar") float s); + + /**\brief Multiply this quaternion by q on the right + * @param q The other quaternion + * Equivilant to this = this * q */ + public native @ByRef @Name("operator *=") btQuaternion multiplyPut(@Const @ByRef btQuaternion q); + /**\brief Return the dot product between this quaternion and another + * @param q The other quaternion */ + public native @Cast("btScalar") float dot(@Const @ByRef btQuaternion q); + + /**\brief Return the length squared of the quaternion */ + public native @Cast("btScalar") float length2(); + + /**\brief Return the length of the quaternion */ + public native @Cast("btScalar") float length(); + public native @ByRef btQuaternion safeNormalize(); + /**\brief Normalize the quaternion + * Such that x^2 + y^2 + z^2 +w^2 = 1 */ + public native @ByRef btQuaternion normalize(); + + /**\brief Return a scaled version of this quaternion + * @param s The scale factor */ + public native @ByVal @Name("operator *") btQuaternion multiply(@Cast("const btScalar") float s); + + /**\brief Return an inversely scaled versionof this quaternion + * @param s The inverse scale factor */ + public native @ByVal @Name("operator /") btQuaternion divide(@Cast("const btScalar") float s); + + /**\brief Inversely scale this quaternion + * @param s The scale factor */ + public native @ByRef @Name("operator /=") btQuaternion dividePut(@Cast("const btScalar") float s); + + /**\brief Return a normalized version of this quaternion */ + public native @ByVal btQuaternion normalized(); + /**\brief Return the ***half*** angle between this quaternion and the other + * @param q The other quaternion */ + public native @Cast("btScalar") float angle(@Const @ByRef btQuaternion q); + + /**\brief Return the angle between this quaternion and the other along the shortest path + * @param q The other quaternion */ + public native @Cast("btScalar") float angleShortestPath(@Const @ByRef btQuaternion q); + + /**\brief Return the angle [0, 2Pi] of rotation represented by this quaternion */ + public native @Cast("btScalar") float getAngle(); + + /**\brief Return the angle [0, Pi] of rotation represented by this quaternion along the shortest path */ + public native @Cast("btScalar") float getAngleShortestPath(); + + /**\brief Return the axis of the rotation represented by this quaternion */ + public native @ByVal btVector3 getAxis(); + + /**\brief Return the inverse of this quaternion */ + public native @ByVal btQuaternion inverse(); + + /**\brief Return the sum of this quaternion and the other + * @param q2 The other quaternion */ + public native @ByVal @Name("operator +") btQuaternion add(@Const @ByRef btQuaternion q2); + + /**\brief Return the difference between this quaternion and the other + * @param q2 The other quaternion */ + public native @ByVal @Name("operator -") btQuaternion subtract(@Const @ByRef btQuaternion q2); + + /**\brief Return the negative of this quaternion + * This simply negates each element */ + public native @ByVal @Name("operator -") btQuaternion subtract(); + /**\todo document this and it's use */ + public native @ByVal btQuaternion farthest(@Const @ByRef btQuaternion qd); + + /**\todo document this and it's use */ + public native @ByVal btQuaternion nearest(@Const @ByRef btQuaternion qd); + + /**\brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion + * @param q The other quaternion to interpolate with + * @param t The ratio between this and q to interpolate. If t = 0 the result is this, if t=1 the result is q. + * Slerp interpolates assuming constant velocity. */ + public native @ByVal btQuaternion slerp(@Const @ByRef btQuaternion q, @Cast("const btScalar") float t); + + public static native @Const @ByRef btQuaternion getIdentity(); + + public native @Cast("const btScalar") float getW(); + + public native void serialize(@ByRef btQuaternionFloatData dataOut); + + public native void deSerialize(@Const @ByRef btQuaternionFloatData dataIn); + + public native void deSerialize(@Const @ByRef btQuaternionDoubleData dataIn); + + public native void serializeFloat(@ByRef btQuaternionFloatData dataOut); + + public native void deSerializeFloat(@Const @ByRef btQuaternionFloatData dataIn); + + public native void serializeDouble(@ByRef btQuaternionDoubleData dataOut); + + public native void deSerializeDouble(@Const @ByRef btQuaternionDoubleData dataIn); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java new file mode 100644 index 00000000000..da01d65ac5f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btQuaternionDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuaternionDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuaternionDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuaternionDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuaternionDoubleData position(long position) { + return (btQuaternionDoubleData)super.position(position); + } + @Override public btQuaternionDoubleData getPointer(long i) { + return new btQuaternionDoubleData((Pointer)this).offsetAddress(i); + } + + public native double m_floats(int i); public native btQuaternionDoubleData m_floats(int i, double setter); + @MemberGetter public native DoublePointer m_floats(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java new file mode 100644 index 00000000000..250b313356a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btQuaternionFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btQuaternionFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuaternionFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuaternionFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btQuaternionFloatData position(long position) { + return (btQuaternionFloatData)super.position(position); + } + @Override public btQuaternionFloatData getPointer(long i) { + return new btQuaternionFloatData((Pointer)this).offsetAddress(i); + } + + public native float m_floats(int i); public native btQuaternionFloatData m_floats(int i, float setter); + @MemberGetter public native FloatPointer m_floats(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java new file mode 100644 index 00000000000..720f1499c7b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java @@ -0,0 +1,53 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btSerializer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSerializer(Pointer p) { super(p); } + + + public native @Cast("const unsigned char*") BytePointer getBufferPointer(); + + public native int getCurrentBufferSize(); + + public native @Name("allocate") btChunk _allocate(@Cast("size_t") long size, int numElements); + + public native void finalizeChunk(btChunk chunk, @Cast("const char*") BytePointer structType, int chunkCode, Pointer oldPtr); + public native void finalizeChunk(btChunk chunk, String structType, int chunkCode, Pointer oldPtr); + + public native Pointer findPointer(Pointer oldPtr); + + public native Pointer getUniquePointer(Pointer oldPtr); + + public native void startSerialization(); + + public native void finishSerialization(); + + public native @Cast("const char*") BytePointer findNameForPointer(@Const Pointer ptr); + + public native void registerNameForPointer(@Const Pointer ptr, @Cast("const char*") BytePointer name); + public native void registerNameForPointer(@Const Pointer ptr, String name); + + public native void serializeName(@Cast("const char*") BytePointer ptr); + public native void serializeName(String ptr); + + public native int getSerializationFlags(); + + public native void setSerializationFlags(int flags); + + public native int getNumChunks(); + + public native @Const btChunk getChunk(int chunkIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransform.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransform.java new file mode 100644 index 00000000000..cfcf79e5f23 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransform.java @@ -0,0 +1,147 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +// #endif + +/**\brief The btTransform class supports rigid transforms with only translation and rotation and no scaling/shear. + *It can be used in combination with btVector3, btQuaternion and btMatrix3x3 linear algebra classes. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btTransform extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTransform(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTransform(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTransform position(long position) { + return (btTransform)super.position(position); + } + @Override public btTransform getPointer(long i) { + return new btTransform((Pointer)this).offsetAddress(i); + } + + /**\brief No initialization constructor */ + public btTransform() { super((Pointer)null); allocate(); } + private native void allocate(); + /**\brief Constructor from btQuaternion (optional btVector3 ) + * @param q Rotation from quaternion + * @param c Translation from Vector (default 0,0,0) */ + public btTransform(@Const @ByRef btQuaternion q, + @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c) { super((Pointer)null); allocate(q, c); } + private native void allocate(@Const @ByRef btQuaternion q, + @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c); + public btTransform(@Const @ByRef btQuaternion q) { super((Pointer)null); allocate(q); } + private native void allocate(@Const @ByRef btQuaternion q); + + /**\brief Constructor from btMatrix3x3 (optional btVector3) + * @param b Rotation from Matrix + * @param c Translation from Vector default (0,0,0)*/ + public btTransform(@Const @ByRef btMatrix3x3 b, + @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c) { super((Pointer)null); allocate(b, c); } + private native void allocate(@Const @ByRef btMatrix3x3 b, + @Const @ByRef(nullValue = "btVector3(btScalar(0), btScalar(0), btScalar(0))") btVector3 c); + public btTransform(@Const @ByRef btMatrix3x3 b) { super((Pointer)null); allocate(b); } + private native void allocate(@Const @ByRef btMatrix3x3 b); + /**\brief Copy constructor */ + public btTransform(@Const @ByRef btTransform other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btTransform other); + /**\brief Assignment Operator */ + public native @ByRef @Name("operator =") btTransform put(@Const @ByRef btTransform other); + + /**\brief Set the current transform as the value of the product of two transforms + * @param t1 Transform 1 + * @param t2 Transform 2 + * This = Transform1 * Transform2 */ + public native void mult(@Const @ByRef btTransform t1, @Const @ByRef btTransform t2); + + /* void multInverseLeft(const btTransform& t1, const btTransform& t2) { + btVector3 v = t2.m_origin - t1.m_origin; + m_basis = btMultTransposeLeft(t1.m_basis, t2.m_basis); + m_origin = v * t1.m_basis; + } + */ + + /**\brief Return the transform of the vector */ + public native @ByVal @Name("operator ()") btVector3 apply(@Const @ByRef btVector3 x); + + /**\brief Return the transform of the vector */ + public native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 x); + + /**\brief Return the transform of the btQuaternion */ + public native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q); + + /**\brief Return the basis matrix for the rotation */ + public native @ByRef btMatrix3x3 getBasis(); + /**\brief Return the basis matrix for the rotation */ + + /**\brief Return the origin vector translation */ + public native @ByRef btVector3 getOrigin(); + /**\brief Return the origin vector translation */ + + /**\brief Return a quaternion representing the rotation */ + public native @ByVal btQuaternion getRotation(); + + /**\brief Set from an array + * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */ + public native void setFromOpenGLMatrix(@Cast("const btScalar*") FloatPointer m); + public native void setFromOpenGLMatrix(@Cast("const btScalar*") FloatBuffer m); + public native void setFromOpenGLMatrix(@Cast("const btScalar*") float[] m); + + /**\brief Fill an array representation + * @param m A pointer to a 16 element array (12 rotation(row major padded on the right by 1), and 3 translation */ + public native void getOpenGLMatrix(@Cast("btScalar*") FloatPointer m); + public native void getOpenGLMatrix(@Cast("btScalar*") FloatBuffer m); + public native void getOpenGLMatrix(@Cast("btScalar*") float[] m); + + /**\brief Set the translational element + * @param origin The vector to set the translation to */ + public native void setOrigin(@Const @ByRef btVector3 origin); + + public native @ByVal btVector3 invXform(@Const @ByRef btVector3 inVec); + + /**\brief Set the rotational element by btMatrix3x3 */ + public native void setBasis(@Const @ByRef btMatrix3x3 basis); + + /**\brief Set the rotational element by btQuaternion */ + public native void setRotation(@Const @ByRef btQuaternion q); + + /**\brief Set this transformation to the identity */ + public native void setIdentity(); + + /**\brief Multiply this Transform by another(this = this * another) + * @param t The other transform */ + public native @ByRef @Name("operator *=") btTransform multiplyPut(@Const @ByRef btTransform t); + + /**\brief Return the inverse of this transform */ + public native @ByVal btTransform inverse(); + + /**\brief Return the inverse of this transform times the other transform + * @param t The other transform + * return this.inverse() * the other */ + public native @ByVal btTransform inverseTimes(@Const @ByRef btTransform t); + + /**\brief Return the product of this transform and the other */ + public native @ByVal @Name("operator *") btTransform multiply(@Const @ByRef btTransform t); + + /**\brief Return an identity transform */ + public static native @Const @ByRef btTransform getIdentity(); + + public native void serialize(@ByRef btTransformFloatData dataOut); + + public native void serializeFloat(@ByRef btTransformFloatData dataOut); + + public native void deSerialize(@Const @ByRef btTransformFloatData dataIn); + + public native void deSerializeDouble(@Const @ByRef btTransformDoubleData dataIn); + + public native void deSerializeFloat(@Const @ByRef btTransformFloatData dataIn); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformDoubleData.java new file mode 100644 index 00000000000..c6baae1ec1a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformDoubleData.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btTransformDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTransformDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTransformDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTransformDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTransformDoubleData position(long position) { + return (btTransformDoubleData)super.position(position); + } + @Override public btTransformDoubleData getPointer(long i) { + return new btTransformDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3DoubleData m_basis(); public native btTransformDoubleData m_basis(btMatrix3x3DoubleData setter); + public native @ByRef btVector3DoubleData m_origin(); public native btTransformDoubleData m_origin(btVector3DoubleData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformFloatData.java new file mode 100644 index 00000000000..54fea2bae28 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformFloatData.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**for serialization */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btTransformFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTransformFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTransformFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTransformFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTransformFloatData position(long position) { + return (btTransformFloatData)super.position(position); + } + @Override public btTransformFloatData getPointer(long i) { + return new btTransformFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3FloatData m_basis(); public native btTransformFloatData m_basis(btMatrix3x3FloatData setter); + public native @ByRef btVector3FloatData m_origin(); public native btTransformFloatData m_origin(btVector3FloatData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java new file mode 100644 index 00000000000..565d183a7d6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**rudimentary class to provide type info */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btTypedObject extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTypedObject(Pointer p) { super(p); } + + public btTypedObject(int objectType) { super((Pointer)null); allocate(objectType); } + private native void allocate(int objectType); + public native int m_objectType(); public native btTypedObject m_objectType(int setter); + public native int getObjectType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java new file mode 100644 index 00000000000..8ff22b11047 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java @@ -0,0 +1,238 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +// #endif //BT_USE_DOUBLE_PRECISION + +// #if defined BT_USE_SSE + +// #endif + +// #ifdef BT_USE_NEON + +// #endif + +/**\brief btVector3 can be used to represent 3D points and vectors. + * It has an un-used w component to suit 16-byte alignment when btVector3 is stored in containers. This extra component can be used by derived classes (Quaternion?) or by user + * Ideally, this class should be replaced by a platform optimized SIMD version that keeps the data in registers + */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btVector3 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVector3(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVector3(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVector3 position(long position) { + return (btVector3)super.position(position); + } + @Override public btVector3 getPointer(long i) { + return new btVector3((Pointer)this).offsetAddress(i); + } + + +// #if defined(__SPU__) && defined(__CELLOS_LV2__) +// #else //__CELLOS_LV2__ __SPU__ +// #if defined(BT_USE_SSE) || defined(BT_USE_NEON) // _WIN32 || ARM +// #else + public native @Cast("btScalar") float m_floats(int i); public native btVector3 m_floats(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_floats(); + /**\brief No initialization constructor */ + public btVector3() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**\brief Constructor from scalars + * @param x X value + * @param y Y value + * @param z Z value + */ + public btVector3(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z) { super((Pointer)null); allocate(_x, _y, _z); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) +// #endif // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON) + + /**\brief Add a vector to this one + * @param The vector to add to this one */ + public native @ByRef @Name("operator +=") btVector3 addPut(@Const @ByRef btVector3 v); + + /**\brief Subtract a vector from this one + * @param The vector to subtract */ + public native @ByRef @Name("operator -=") btVector3 subtractPut(@Const @ByRef btVector3 v); + + /**\brief Scale the vector + * @param s Scale factor */ + public native @ByRef @Name("operator *=") btVector3 multiplyPut(@Cast("const btScalar") float s); + + /**\brief Inversely scale the vector + * @param s Scale factor to divide by */ + public native @ByRef @Name("operator /=") btVector3 dividePut(@Cast("const btScalar") float s); + + /**\brief Return the dot product + * @param v The other vector in the dot product */ + public native @Cast("btScalar") float dot(@Const @ByRef btVector3 v); + + /**\brief Return the length of the vector squared */ + public native @Cast("btScalar") float length2(); + + /**\brief Return the length of the vector */ + public native @Cast("btScalar") float length(); + + /**\brief Return the norm (length) of the vector */ + public native @Cast("btScalar") float norm(); + + /**\brief Return the norm (length) of the vector */ + public native @Cast("btScalar") float safeNorm(); + + /**\brief Return the distance squared between the ends of this and another vector + * This is symantically treating the vector like a point */ + public native @Cast("btScalar") float distance2(@Const @ByRef btVector3 v); + + /**\brief Return the distance between the ends of this and another vector + * This is symantically treating the vector like a point */ + public native @Cast("btScalar") float distance(@Const @ByRef btVector3 v); + + public native @ByRef btVector3 safeNormalize(); + + /**\brief Normalize this vector + * x^2 + y^2 + z^2 = 1 */ + public native @ByRef btVector3 normalize(); + + /**\brief Return a normalized version of this vector */ + public native @ByVal btVector3 normalized(); + + /**\brief Return a rotated version of this vector + * @param wAxis The axis to rotate about + * @param angle The angle to rotate by */ + public native @ByVal btVector3 rotate(@Const @ByRef btVector3 wAxis, @Cast("const btScalar") float angle); + + /**\brief Return the angle between this and another vector + * @param v The other vector */ + public native @Cast("btScalar") float angle(@Const @ByRef btVector3 v); + + /**\brief Return a vector with the absolute values of each element */ + public native @ByVal btVector3 absolute(); + + /**\brief Return the cross product between this and another vector + * @param v The other vector */ + public native @ByVal btVector3 cross(@Const @ByRef btVector3 v); + + public native @Cast("btScalar") float triple(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + + /**\brief Return the axis with the smallest value + * Note return values are 0,1,2 for x, y, or z */ + public native int minAxis(); + + /**\brief Return the axis with the largest value + * Note return values are 0,1,2 for x, y, or z */ + public native int maxAxis(); + + public native int furthestAxis(); + + public native int closestAxis(); + + public native void setInterpolate3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Cast("btScalar") float rt); + + /**\brief Return the linear interpolation between this and another vector + * @param v The other vector + * @param t The ration of this to v (t = 0 => return this, t=1 => return other) */ + public native @ByVal btVector3 lerp(@Const @ByRef btVector3 v, @Cast("const btScalar") float t); + + /**\brief Elementwise multiply this vector by the other + * @param v The other vector */ + public native @ByRef @Name("operator *=") btVector3 multiplyPut(@Const @ByRef btVector3 v); + + /**\brief Return the x value */ + public native @Cast("const btScalar") float getX(); + /**\brief Return the y value */ + public native @Cast("const btScalar") float getY(); + /**\brief Return the z value */ + public native @Cast("const btScalar") float getZ(); + /**\brief Set the x value */ + public native void setX(@Cast("btScalar") float _x); + /**\brief Set the y value */ + public native void setY(@Cast("btScalar") float _y); + /**\brief Set the z value */ + public native void setZ(@Cast("btScalar") float _z); + /**\brief Set the w value */ + public native void setW(@Cast("btScalar") float _w); + /**\brief Return the x value */ + public native @Cast("const btScalar") float x(); + /**\brief Return the y value */ + public native @Cast("const btScalar") float y(); + /**\brief Return the z value */ + public native @Cast("const btScalar") float z(); + /**\brief Return the w value */ + public native @Cast("const btScalar") float w(); + + //SIMD_FORCE_INLINE btScalar& operator[](int i) { return (&m_floats[0])[i]; } + //SIMD_FORCE_INLINE const btScalar& operator[](int i) const { return (&m_floats[0])[i]; } + /**operator btScalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. */ + public native @Cast("btScalar*") @Name("operator btScalar*") FloatPointer asFloatPointer(); + + public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btVector3 other); + + public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef btVector3 other); + + /**\brief Set each element to the max of the current values and the values of another btVector3 + * @param other The other btVector3 to compare with + */ + public native void setMax(@Const @ByRef btVector3 other); + + /**\brief Set each element to the min of the current values and the values of another btVector3 + * @param other The other btVector3 to compare with + */ + public native void setMin(@Const @ByRef btVector3 other); + + public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z); + + public native void getSkewSymmetricMatrix(btVector3 v0, btVector3 v1, btVector3 v2); + + public native void setZero(); + + public native @Cast("bool") boolean isZero(); + + public native @Cast("bool") boolean fuzzyZero(); + + public native void serialize(@ByRef btVector3FloatData dataOut); + + public native void deSerialize(@Const @ByRef btVector3DoubleData dataIn); + + public native void deSerialize(@Const @ByRef btVector3FloatData dataIn); + + public native void serializeFloat(@ByRef btVector3FloatData dataOut); + + public native void deSerializeFloat(@Const @ByRef btVector3FloatData dataIn); + + public native void serializeDouble(@ByRef btVector3DoubleData dataOut); + + public native void deSerializeDouble(@Const @ByRef btVector3DoubleData dataIn); + + /**\brief returns index of maximum dot product between this and vectors in array[] + * @param array The other vectors + * @param array_count The number of other vectors + * @param dotOut The maximum dot product */ + public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatPointer dotOut); + public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatBuffer dotOut); + public native long maxDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef float[] dotOut); + + /**\brief returns index of minimum dot product between this and vectors in array[] + * @param array The other vectors + * @param array_count The number of other vectors + * @param dotOut The minimum dot product */ + public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatPointer dotOut); + public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef FloatBuffer dotOut); + public native long minDot(@Const btVector3 array, long array_count, @Cast("btScalar*") @ByRef float[] dotOut); + + /* create a vector as btVector3( this->dot( btVector3 v0 ), this->dot( btVector3 v1), this->dot( btVector3 v2 )) */ + public native @ByVal btVector3 dot3(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3DoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3DoubleData.java new file mode 100644 index 00000000000..30494587eff --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3DoubleData.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btVector3DoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btVector3DoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVector3DoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVector3DoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btVector3DoubleData position(long position) { + return (btVector3DoubleData)super.position(position); + } + @Override public btVector3DoubleData getPointer(long i) { + return new btVector3DoubleData((Pointer)this).offsetAddress(i); + } + + public native double m_floats(int i); public native btVector3DoubleData m_floats(int i, double setter); + @MemberGetter public native DoublePointer m_floats(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java new file mode 100644 index 00000000000..0c543609465 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btVector3FloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btVector3FloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVector3FloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVector3FloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btVector3FloatData position(long position) { + return (btVector3FloatData)super.position(position); + } + @Override public btVector3FloatData getPointer(long i) { + return new btVector3FloatData((Pointer)this).offsetAddress(i); + } + + public native float m_floats(int i); public native btVector3FloatData m_floats(int i, float setter); + @MemberGetter public native FloatPointer m_floats(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java new file mode 100644 index 00000000000..8b007f2dbb0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java @@ -0,0 +1,68 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btVector4 extends btVector3 { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVector4(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVector4(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVector4 position(long position) { + return (btVector4)super.position(position); + } + @Override public btVector4 getPointer(long i) { + return new btVector4((Pointer)this).offsetAddress(i); + } + + public btVector4() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btVector4(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); + +// #if (defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON) +// #endif // #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON) + + public native @ByVal btVector4 absolute4(); + + public native @Cast("btScalar") float getW(); + + public native int maxAxis4(); + + public native int minAxis4(); + + public native int closestAxis4(); + + /**\brief Set x,y,z and zero w + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + + /* void getValue(btScalar *m) const + { + m[0] = m_floats[0]; + m[1] = m_floats[1]; + m[2] =m_floats[2]; + } +*/ + /**\brief Set the values + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public native void setValue(@Cast("const btScalar") float _x, @Cast("const btScalar") float _y, @Cast("const btScalar") float _z, @Cast("const btScalar") float _w); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java new file mode 100644 index 00000000000..65d7755c4aa --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -0,0 +1,1884 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.global; + +import org.bytedeco.bullet.BulletCollision.*; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision { + static { Loader.load(); } + +// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseProxy.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BROADPHASE_PROXY_H +// #define BT_BROADPHASE_PROXY_H + +// #include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedAllocator.h" + +/** btDispatcher uses these types + * IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave + * to facilitate type checking + * CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code */ +/** enum BroadphaseNativeTypes */ +public static final int + // polyhedral convex shapes + BOX_SHAPE_PROXYTYPE = 0, + TRIANGLE_SHAPE_PROXYTYPE = 1, + TETRAHEDRAL_SHAPE_PROXYTYPE = 2, + CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE = 3, + CONVEX_HULL_SHAPE_PROXYTYPE = 4, + CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE = 5, + CUSTOM_POLYHEDRAL_SHAPE_TYPE = 6, + //implicit convex shapes + IMPLICIT_CONVEX_SHAPES_START_HERE = 7, + SPHERE_SHAPE_PROXYTYPE = 8, + MULTI_SPHERE_SHAPE_PROXYTYPE = 9, + CAPSULE_SHAPE_PROXYTYPE = 10, + CONE_SHAPE_PROXYTYPE = 11, + CONVEX_SHAPE_PROXYTYPE = 12, + CYLINDER_SHAPE_PROXYTYPE = 13, + UNIFORM_SCALING_SHAPE_PROXYTYPE = 14, + MINKOWSKI_SUM_SHAPE_PROXYTYPE = 15, + MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE = 16, + BOX_2D_SHAPE_PROXYTYPE = 17, + CONVEX_2D_SHAPE_PROXYTYPE = 18, + CUSTOM_CONVEX_SHAPE_TYPE = 19, + //concave shapes + CONCAVE_SHAPES_START_HERE = 20, + //keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy! + TRIANGLE_MESH_SHAPE_PROXYTYPE = 21, + SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE = 22, + /**used for demo integration FAST/Swift collision library and Bullet */ + FAST_CONCAVE_MESH_PROXYTYPE = 23, + //terrain + TERRAIN_SHAPE_PROXYTYPE = 24, + /**Used for GIMPACT Trimesh integration */ + GIMPACT_SHAPE_PROXYTYPE = 25, + /**Multimaterial mesh */ + MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE = 26, + + EMPTY_SHAPE_PROXYTYPE = 27, + STATIC_PLANE_PROXYTYPE = 28, + CUSTOM_CONCAVE_SHAPE_TYPE = 29, + SDF_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE, + CONCAVE_SHAPES_END_HERE = CUSTOM_CONCAVE_SHAPE_TYPE + 1, + + COMPOUND_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 2, + + SOFTBODY_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 3, + HFFLUID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 4, + HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 5, + INVALID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 6, + + MAX_BROADPHASE_COLLISION_TYPES = CUSTOM_CONCAVE_SHAPE_TYPE + 7; +// Targeting ../BulletCollision/btBroadphaseProxy.java + + +// Targeting ../BulletCollision/btCollisionAlgorithm.java + + +// Targeting ../BulletCollision/btBroadphasePair.java + + +// Targeting ../BulletCollision/btBroadphasePairSortPredicate.java + + + +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btBroadphasePair a, @Const @ByRef btBroadphasePair b); + +// #endif //BT_BROADPHASE_PROXY_H + + +// Parsed from BulletCollision/BroadphaseCollision/btDispatcher.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DISPATCHER_H +// #define BT_DISPATCHER_H +// #include "LinearMath/btScalar.h" +// Targeting ../BulletCollision/btRigidBody.java + + +// Targeting ../BulletCollision/btCollisionObjectWrapper.java + + +// Targeting ../BulletCollision/btPersistentManifold.java + + +// Targeting ../BulletCollision/btPoolAllocator.java + + +// Targeting ../BulletCollision/btDispatcherInfo.java + + + +/** enum ebtDispatcherQueryType */ +public static final int + BT_CONTACT_POINT_ALGORITHMS = 1, + BT_CLOSEST_POINT_ALGORITHMS = 2; +// Targeting ../BulletCollision/btDispatcher.java + + + +// #endif //BT_DISPATCHER_H + + +// Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h + + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef OVERLAPPING_PAIR_CALLBACK_H +// #define OVERLAPPING_PAIR_CALLBACK_H +// Targeting ../BulletCollision/btOverlappingPairCallback.java + + + +// #endif //OVERLAPPING_PAIR_CALLBACK_H + + +// Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCache.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OVERLAPPING_PAIR_CACHE_H +// #define BT_OVERLAPPING_PAIR_CACHE_H + +// #include "btBroadphaseInterface.h" +// #include "btBroadphaseProxy.h" +// #include "btOverlappingPairCallback.h" + +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btOverlapCallback.java + + +// Targeting ../BulletCollision/btOverlapFilterCallback.java + + + +@MemberGetter public static native int BT_NULL_PAIR(); +// Targeting ../BulletCollision/btOverlappingPairCache.java + + +// Targeting ../BulletCollision/btHashedOverlappingPairCache.java + + +// Targeting ../BulletCollision/btSortedOverlappingPairCache.java + + +// Targeting ../BulletCollision/btNullPairCache.java + + + +// #endif //BT_OVERLAPPING_PAIR_CACHE_H + + +// Parsed from BulletCollision/BroadphaseCollision/btQuantizedBvh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_QUANTIZED_BVH_H +// #define BT_QUANTIZED_BVH_H + +//#define DEBUG_CHECK_DEQUANTIZATION 1 +// #ifdef DEBUG_CHECK_DEQUANTIZATION +// #ifdef __SPU__ +// #endif //__SPU__ + +// #include +// #include +// #endif //DEBUG_CHECK_DEQUANTIZATION + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedAllocator.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btQuantizedBvhData btQuantizedBvhFloatData +// #define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData +public static final String btQuantizedBvhDataName = "btQuantizedBvhFloatData"; +// #endif + +//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp + +//Note: currently we have 16 bytes per quantized node +public static final int MAX_SUBTREE_SIZE_IN_BYTES = 2048; + +// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one +// actually) triangles each (since the sign bit is reserved +public static final int MAX_NUM_PARTS_IN_BITS = 10; +// Targeting ../BulletCollision/btQuantizedBvhNode.java + + +// Targeting ../BulletCollision/btOptimizedBvhNode.java + + +// Targeting ../BulletCollision/btBvhSubtreeInfo.java + + +// Targeting ../BulletCollision/btNodeOverlapCallback.java + + + +// #include "LinearMath/btAlignedAllocator.h" +// #include "LinearMath/btAlignedObjectArray.h" + +/**for code readability: */ +// Targeting ../BulletCollision/btQuantizedBvh.java + + +// Targeting ../BulletCollision/btBvhSubtreeInfoData.java + + +// Targeting ../BulletCollision/btOptimizedBvhNodeFloatData.java + + +// Targeting ../BulletCollision/btOptimizedBvhNodeDoubleData.java + + +// Targeting ../BulletCollision/btQuantizedBvhNodeData.java + + +// Targeting ../BulletCollision/btQuantizedBvhFloatData.java + + +// Targeting ../BulletCollision/btQuantizedBvhDoubleData.java + + +// clang-format on + + + +// #endif //BT_QUANTIZED_BVH_H + + +// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BROADPHASE_INTERFACE_H +// #define BT_BROADPHASE_INTERFACE_H +// #include "btBroadphaseProxy.h" +// Targeting ../BulletCollision/btBroadphaseAabbCallback.java + + +// Targeting ../BulletCollision/btBroadphaseRayCallback.java + + + +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btBroadphaseInterface.java + + + +// #endif //BT_BROADPHASE_INTERFACE_H + + +// Parsed from BulletCollision/BroadphaseCollision/btSimpleBroadphase.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMPLE_BROADPHASE_H +// #define BT_SIMPLE_BROADPHASE_H + +// #include "btOverlappingPairCache.h" +// Targeting ../BulletCollision/btSimpleBroadphaseProxy.java + + +// Targeting ../BulletCollision/btSimpleBroadphase.java + + + +// #endif //BT_SIMPLE_BROADPHASE_H + + +// Parsed from BulletCollision/BroadphaseCollision/btAxisSweep3.h + +//Bullet Continuous Collision Detection and Physics Library +//Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +// +// btAxisSweep3.h +// +// Copyright (c) 2006 Simon Hobbs +// +// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. + +// #ifndef BT_AXIS_SWEEP_3_H +// #define BT_AXIS_SWEEP_3_H + +// #include "LinearMath/btVector3.h" +// #include "btOverlappingPairCache.h" +// #include "btBroadphaseInterface.h" +// #include "btBroadphaseProxy.h" +// #include "btOverlappingPairCallback.h" +// #include "btDbvtBroadphase.h" +// #include "btAxisSweep3Internal.h" +// Targeting ../BulletCollision/btAxisSweep3.java + + +// Targeting ../BulletCollision/bt32BitAxisSweep3.java + + + +// #endif + + +// Parsed from BulletCollision/BroadphaseCollision/btDbvtBroadphase.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**btDbvtBroadphase implementation by Nathanael Presson */ +// #ifndef BT_DBVT_BROADPHASE_H +// #define BT_DBVT_BROADPHASE_H + +// #include "BulletCollision/BroadphaseCollision/btDbvt.h" +// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" + +// +// Compile time config +// + +public static native @MemberGetter int DBVT_BP_PROFILE(); +public static final int DBVT_BP_PROFILE = DBVT_BP_PROFILE(); +//#define DBVT_BP_SORTPAIRS 1 +public static final int DBVT_BP_PREVENTFALSEUPDATE = 0; +public static final int DBVT_BP_ACCURATESLEEPING = 0; +public static final int DBVT_BP_ENABLE_BENCHMARK = 0; +//#define DBVT_BP_MARGIN (btScalar)0.05 +public static native @Cast("btScalar") float gDbvtMargin(); public static native void gDbvtMargin(float setter); + +// #if DBVT_BP_PROFILE +// #endif + +// +// btDbvtProxy +// +// Targeting ../BulletCollision/btDbvtBroadphase.java + + + +// #endif + + +// Parsed from BulletCollision/NarrowPhaseCollision/btManifoldPoint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MANIFOLD_CONTACT_POINT_H +// #define BT_MANIFOLD_CONTACT_POINT_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransformUtil.h" +// Targeting ../BulletCollision/btConstraintRow.java + + +// #endif //PFX_USE_FREE_VECTORMATH + +/** enum btContactPointFlags */ +public static final int + BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED = 1, + BT_CONTACT_FLAG_HAS_CONTACT_CFM = 2, + BT_CONTACT_FLAG_HAS_CONTACT_ERP = 4, + BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING = 8, + BT_CONTACT_FLAG_FRICTION_ANCHOR = 16; +// Targeting ../BulletCollision/btManifoldPoint.java + + + +// #endif //BT_MANIFOLD_CONTACT_POINT_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H +// #define BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btDiscreteCollisionDetectorInterface.java + + +// Targeting ../BulletCollision/btStorageResult.java + + + +// #endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionObject.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_OBJECT_H +// #define BT_COLLISION_OBJECT_H + +// #include "LinearMath/btTransform.h" + +//island management, m_activationState1 +public static final int ACTIVE_TAG = 1; +public static final int ISLAND_SLEEPING = 2; +public static final int WANTS_DEACTIVATION = 3; +public static final int DISABLE_DEACTIVATION = 4; +public static final int DISABLE_SIMULATION = 5; +public static final int FIXED_BASE_MULTI_BODY = 6; +// #include "LinearMath/btMotionState.h" +// #include "LinearMath/btAlignedAllocator.h" +// #include "LinearMath/btAlignedObjectArray.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btCollisionObjectData btCollisionObjectFloatData +public static final String btCollisionObjectDataName = "btCollisionObjectFloatData"; +// Targeting ../BulletCollision/btCollisionObject.java + + +// Targeting ../BulletCollision/btCollisionObjectDoubleData.java + + +// Targeting ../BulletCollision/btCollisionObjectFloatData.java + + +// clang-format on + + + +// #endif //BT_COLLISION_OBJECT_H + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionCreateFunc.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_CREATE_FUNC +// #define BT_COLLISION_CREATE_FUNC + +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btCollisionAlgorithmConstructionInfo.java + + +// Targeting ../BulletCollision/btCollisionAlgorithmCreateFunc.java + + +// #endif //BT_COLLISION_CREATE_FUNC + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionDispatcher.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION__DISPATCHER_H +// #define BT_COLLISION__DISPATCHER_H + +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +// #include "BulletCollision/CollisionDispatch/btManifoldResult.h" + +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btCollisionConfiguration.java + + + +// #include "btCollisionCreateFunc.h" + +public static final int USE_DISPATCH_REGISTRY_ARRAY = 1; +// Targeting ../BulletCollision/btNearCallback.java + + +// Targeting ../BulletCollision/btCollisionDispatcher.java + + + +// #endif //BT_COLLISION__DISPATCHER_H + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/** + * \mainpage Bullet Documentation + * + * \section intro_sec Introduction + * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ). + * + * The main documentation is Bullet_User_Manual.pdf, included in the source code distribution. + * There is the Physics Forum for feedback and general Collision Detection and Physics discussions. + * Please visit http://www.bulletphysics.org + * + * \section install_sec Installation + * + * \subsection step1 Step 1: Download + * You can download the Bullet Physics Library from the github repository: https://github.com/bulletphysics/bullet3/releases + * + * \subsection step2 Step 2: Building + * Bullet has multiple build systems, including premake, cmake and autotools. Premake and cmake support all platforms. + * Premake is included in the Bullet/build folder for Windows, Mac OSX and Linux. + * Under Windows you can click on Bullet/build/vs2010.bat to create Microsoft Visual Studio projects. + * On Mac OSX and Linux you can open a terminal and generate Makefile, codeblocks or Xcode4 projects: + * cd Bullet/build + * ./premake4_osx gmake or ./premake4_linux gmake or ./premake4_linux64 gmake or (for Mac) ./premake4_osx xcode4 + * cd Bullet/build/gmake + * make + * + * An alternative to premake is cmake. You can download cmake from http://www.cmake.org + * cmake can autogenerate projectfiles for Microsoft Visual Studio, Apple Xcode, KDevelop and Unix Makefiles. + * The easiest is to run the CMake cmake-gui graphical user interface and choose the options and generate projectfiles. + * You can also use cmake in the command-line. Here are some examples for various platforms: + * cmake . -G "Visual Studio 9 2008" + * cmake . -G Xcode + * cmake . -G "Unix Makefiles" + * Although cmake is recommended, you can also use autotools for UNIX: ./autogen.sh ./configure to create a Makefile and then run make. + * + * \subsection step3 Step 3: Testing demos + * Try to run and experiment with BasicDemo executable as a starting point. + * Bullet can be used in several ways, as Full Rigid Body simulation, as Collision Detector Library or Low Level / Snippets like the GJK Closest Point calculation. + * The Dependencies can be seen in this documentation under Directories + * + * \subsection step4 Step 4: Integrating in your application, full Rigid Body and Soft Body simulation + * Check out BasicDemo how to create a btDynamicsWorld, btRigidBody and btCollisionShape, Stepping the simulation and synchronizing your graphics object transform. + * Check out SoftDemo how to use soft body dynamics, using btSoftRigidDynamicsWorld. + * \subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras) + * Bullet Collision Detection can also be used without the Dynamics/Extras. + * Check out btCollisionWorld and btCollisionObject, and the CollisionInterfaceDemo. + * \subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation. + * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of btGjkPairDetector. + * + * \section copyright Copyright + * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf + * + */ + +// #ifndef BT_COLLISION_WORLD_H +// #define BT_COLLISION_WORLD_H +// Targeting ../BulletCollision/btConvexShape.java + + + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "btCollisionObject.h" +// #include "btCollisionDispatcher.h" +// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btCollisionWorld.java + + + +// #endif //BT_COLLISION_WORLD_H + + +// Parsed from BulletCollision/CollisionDispatch/btManifoldResult.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MANIFOLD_RESULT_H +// #define BT_MANIFOLD_RESULT_H + +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" + +// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" + +// #include "LinearMath/btTransform.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +// Targeting ../BulletCollision/ContactAddedCallback.java + + +public static native ContactAddedCallback gContactAddedCallback(); public static native void gContactAddedCallback(ContactAddedCallback setter); +// Targeting ../BulletCollision/CalculateCombinedCallback.java + + + +public static native CalculateCombinedCallback gCalculateCombinedRestitutionCallback(); public static native void gCalculateCombinedRestitutionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedFrictionCallback(); public static native void gCalculateCombinedFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback(); public static native void gCalculateCombinedRollingFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback(); public static native void gCalculateCombinedSpinningFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedContactDampingCallback(); public static native void gCalculateCombinedContactDampingCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback(); public static native void gCalculateCombinedContactStiffnessCallback(CalculateCombinedCallback setter); +// Targeting ../BulletCollision/btManifoldResult.java + + + +// #endif //BT_MANIFOLD_RESULT_H + + +// Parsed from BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H +// #define __BT_ACTIVATING_COLLISION_ALGORITHM_H + +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// Targeting ../BulletCollision/btActivatingCollisionAlgorithm.java + + +// #endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H + + +// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H + +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "btCollisionDispatcher.h" +// Targeting ../BulletCollision/btSphereSphereCollisionAlgorithm.java + + + +// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H + + +// Parsed from BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DEFAULT_COLLISION_CONFIGURATION +// #define BT_DEFAULT_COLLISION_CONFIGURATION + +// #include "btCollisionConfiguration.h" +// Targeting ../BulletCollision/btVoronoiSimplexSolver.java + + +// Targeting ../BulletCollision/btConvexPenetrationDepthSolver.java + + +// Targeting ../BulletCollision/btDefaultCollisionConstructionInfo.java + + +// Targeting ../BulletCollision/btDefaultCollisionConfiguration.java + + + +// #endif //BT_DEFAULT_COLLISION_CONFIGURATION + + +// Parsed from BulletCollision/CollisionShapes/btCollisionShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_SHAPE_H +// #define BT_COLLISION_SHAPE_H + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types +// Targeting ../BulletCollision/btCollisionShape.java + + +// Targeting ../BulletCollision/btCollisionShapeData.java + + +// clang-format on + + +// #endif //BT_COLLISION_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H +// #define BT_POLYHEDRAL_CONVEX_SHAPE_H + +// #include "LinearMath/btMatrix3x3.h" +// #include "btConvexInternalShape.h" +// Targeting ../BulletCollision/btConvexPolyhedron.java + + +// Targeting ../BulletCollision/btPolyhedralConvexShape.java + + +// Targeting ../BulletCollision/btPolyhedralConvexAabbCachingShape.java + + + +// #endif //BT_POLYHEDRAL_CONVEX_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexInternalShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_INTERNAL_SHAPE_H +// #define BT_CONVEX_INTERNAL_SHAPE_H + +// #include "btConvexShape.h" +// #include "LinearMath/btAabbUtil2.h" +// Targeting ../BulletCollision/btConvexInternalShape.java + + +// Targeting ../BulletCollision/btConvexInternalShapeData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + +// Targeting ../BulletCollision/btConvexInternalAabbCachingShape.java + + + +// #endif //BT_CONVEX_INTERNAL_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btBoxShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBB_BOX_MINKOWSKI_H +// #define BT_OBB_BOX_MINKOWSKI_H + +// #include "btPolyhedralConvexShape.h" +// #include "btCollisionMargin.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMinMax.h" +// Targeting ../BulletCollision/btBoxShape.java + + + +// #endif //BT_OBB_BOX_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btSphereShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_SPHERE_MINKOWSKI_H +// #define BT_SPHERE_MINKOWSKI_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btSphereShape.java + + + +// #endif //BT_SPHERE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btCapsuleShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CAPSULE_SHAPE_H +// #define BT_CAPSULE_SHAPE_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btCapsuleShape.java + + +// Targeting ../BulletCollision/btCapsuleShapeX.java + + +// Targeting ../BulletCollision/btCapsuleShapeZ.java + + +// Targeting ../BulletCollision/btCapsuleShapeData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + + + +// #endif //BT_CAPSULE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btCylinderShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CYLINDER_MINKOWSKI_H +// #define BT_CYLINDER_MINKOWSKI_H + +// #include "btBoxShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btCylinderShape.java + + +// Targeting ../BulletCollision/btCylinderShapeX.java + + +// Targeting ../BulletCollision/btCylinderShapeZ.java + + +// Targeting ../BulletCollision/btCylinderShapeData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_CYLINDER_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btConeShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONE_MINKOWSKI_H +// #define BT_CONE_MINKOWSKI_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btConeShape.java + + +// Targeting ../BulletCollision/btConeShapeX.java + + +// Targeting ../BulletCollision/btConeShapeZ.java + + +// Targeting ../BulletCollision/btConeShapeData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_CONE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btConcaveShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONCAVE_SHAPE_H +// #define BT_CONCAVE_SHAPE_H + +// #include "btCollisionShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "btTriangleCallback.h" + +/** PHY_ScalarType enumerates possible scalar types. + * See the btStridingMeshInterface or btHeightfieldTerrainShape for its use */ +/** enum PHY_ScalarType */ +public static final int + PHY_FLOAT = 0, + PHY_DOUBLE = 1, + PHY_INTEGER = 2, + PHY_SHORT = 3, + PHY_FIXEDPOINT88 = 4, + PHY_UCHAR = 5; +// Targeting ../BulletCollision/btConcaveShape.java + + + +// #endif //BT_CONCAVE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleCallback.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_CALLBACK_H +// #define BT_TRIANGLE_CALLBACK_H + +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btTriangleCallback.java + + +// Targeting ../BulletCollision/btInternalTriangleIndexCallback.java + + + +// #endif //BT_TRIANGLE_CALLBACK_H + + +// Parsed from BulletCollision/CollisionShapes/btStaticPlaneShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_STATIC_PLANE_SHAPE_H +// #define BT_STATIC_PLANE_SHAPE_H + +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btStaticPlaneShape.java + + +// Targeting ../BulletCollision/btStaticPlaneShapeData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_STATIC_PLANE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexHullShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_HULL_SHAPE_H +// #define BT_CONVEX_HULL_SHAPE_H + +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btConvexHullShape.java + + +// Targeting ../BulletCollision/btConvexHullShapeData.java + + + +// clang-format on + + + +// #endif //BT_CONVEX_HULL_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btStridingMeshInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_STRIDING_MESHINTERFACE_H +// #define BT_STRIDING_MESHINTERFACE_H + +// #include "LinearMath/btVector3.h" +// #include "btTriangleCallback.h" +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btStridingMeshInterface.java + + +// Targeting ../BulletCollision/btIntIndexData.java + + +// Targeting ../BulletCollision/btShortIntIndexData.java + + +// Targeting ../BulletCollision/btShortIntIndexTripletData.java + + +// Targeting ../BulletCollision/btCharIndexTripletData.java + + +// Targeting ../BulletCollision/btMeshPartData.java + + +// Targeting ../BulletCollision/btStridingMeshInterfaceData.java + + + +// clang-format on + + + +// #endif //BT_STRIDING_MESHINTERFACE_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H +// #define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H + +// #include "btStridingMeshInterface.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btScalar.h" +// Targeting ../BulletCollision/btIndexedMesh.java + + +// Targeting ../BulletCollision/btTriangleIndexVertexArray.java + + + +// #endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleMesh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_MESH_H +// #define BT_TRIANGLE_MESH_H + +// #include "btTriangleIndexVertexArray.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btTriangleMesh.java + + + +// #endif //BT_TRIANGLE_MESH_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H +// #define BT_CONVEX_TRIANGLEMESH_SHAPE_H + +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btConvexTriangleMeshShape.java + + + +// #endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_MESH_SHAPE_H +// #define BT_TRIANGLE_MESH_SHAPE_H + +// #include "btConcaveShape.h" +// #include "btStridingMeshInterface.h" +// Targeting ../BulletCollision/btTriangleMeshShape.java + + + +// #endif //BT_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btOptimizedBvh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**Contains contributions from Disney Studio's */ + +// #ifndef BT_OPTIMIZED_BVH_H +// #define BT_OPTIMIZED_BVH_H + +// #include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" +// Targeting ../BulletCollision/btOptimizedBvh.java + + + +// #endif //BT_OPTIMIZED_BVH_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleInfoMap.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2010 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef _BT_TRIANGLE_INFO_MAP_H +// #define _BT_TRIANGLE_INFO_MAP_H + +// #include "LinearMath/btHashMap.h" +// #include "LinearMath/btSerializer.h" + +/**for btTriangleInfo m_flags */ +public static final int TRI_INFO_V0V1_CONVEX = 1; +public static final int TRI_INFO_V1V2_CONVEX = 2; +public static final int TRI_INFO_V2V0_CONVEX = 4; + +public static final int TRI_INFO_V0V1_SWAP_NORMALB = 8; +public static final int TRI_INFO_V1V2_SWAP_NORMALB = 16; +public static final int TRI_INFO_V2V0_SWAP_NORMALB = 32; +// Targeting ../BulletCollision/btTriangleInfo.java + + +// Targeting ../BulletCollision/btTriangleInfoMap.java + + +// Targeting ../BulletCollision/btTriangleInfoData.java + + +// Targeting ../BulletCollision/btTriangleInfoMapData.java + + + +// clang-format on + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //_BT_TRIANGLE_INFO_MAP_H + + +// Parsed from BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H +// #define BT_BVH_TRIANGLE_MESH_SHAPE_H + +// #include "btTriangleMeshShape.h" +// #include "btOptimizedBvh.h" +// #include "LinearMath/btAlignedAllocator.h" +// #include "btTriangleInfoMap.h" +// Targeting ../BulletCollision/btBvhTriangleMeshShape.java + + +// Targeting ../BulletCollision/btTriangleMeshShapeData.java + + + +// clang-format on + + + +// #endif //BT_BVH_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +// #define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H + +// #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" +// Targeting ../BulletCollision/btScaledBvhTriangleMeshShape.java + + +// Targeting ../BulletCollision/btScaledTriangleMeshShapeData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btCompoundShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COMPOUND_SHAPE_H +// #define BT_COMPOUND_SHAPE_H + +// #include "btCollisionShape.h" + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btDbvt.java + + +// Targeting ../BulletCollision/btCompoundShapeChild.java + + + +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btCompoundShapeChild c1, @Const @ByRef btCompoundShapeChild c2); +// Targeting ../BulletCollision/btCompoundShape.java + + +// Targeting ../BulletCollision/btCompoundShapeChildData.java + + +// Targeting ../BulletCollision/btCompoundShapeData.java + + + +// clang-format on + + + +// #endif //BT_COMPOUND_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btTetrahedronShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMPLEX_1TO4_SHAPE +// #define BT_SIMPLEX_1TO4_SHAPE + +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btBU_Simplex1to4.java + + + +// #endif //BT_SIMPLEX_1TO4_SHAPE + + +// Parsed from BulletCollision/CollisionShapes/btEmptyShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_EMPTY_SHAPE_H +// #define BT_EMPTY_SHAPE_H + +// #include "btConcaveShape.h" + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// Targeting ../BulletCollision/btEmptyShape.java + + + +// #endif //BT_EMPTY_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btMultiSphereShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTI_SPHERE_MINKOWSKI_H +// #define BT_MULTI_SPHERE_MINKOWSKI_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btAabbUtil2.h" +// Targeting ../BulletCollision/btMultiSphereShape.java + + +// Targeting ../BulletCollision/btPositionAndRadius.java + + +// Targeting ../BulletCollision/btMultiSphereShapeData.java + + + +// clang-format on + + + +// #endif //BT_MULTI_SPHERE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btUniformScalingShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_UNIFORM_SCALING_SHAPE_H +// #define BT_UNIFORM_SCALING_SHAPE_H + +// #include "btConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btUniformScalingShape.java + + + +// #endif //BT_UNIFORM_SCALING_SHAPE_H + + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java new file mode 100644 index 00000000000..1b33c260c15 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -0,0 +1,1070 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.global; + +import org.bytedeco.bullet.BulletDynamics.*; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { + static { Loader.load(); } + +// Parsed from LinearMath/btAlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBJECT_ARRAY__ +// #define BT_OBJECT_ARRAY__ + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +// #include "btAlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW + * then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int BT_USE_PLACEMENT_NEW = 1; +//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef BT_USE_MEMCPY +// #include +// #include +// #endif //BT_USE_MEMCPY + +// #ifdef BT_USE_PLACEMENT_NEW +// #include +// Targeting ../BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java + + + +// #endif //BT_OBJECT_ARRAY__ + + +// Parsed from BulletDynamics/Dynamics/btRigidBody.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_RIGIDBODY_H +// #define BT_RIGIDBODY_H + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btTransform.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +// Targeting ../BulletDynamics/btTypedConstraint.java + + + +public static native @Cast("btScalar") float gDeactivationTime(); public static native void gDeactivationTime(float setter); +public static native @Cast("bool") boolean gDisableDeactivation(); public static native void gDisableDeactivation(boolean setter); + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btRigidBodyData btRigidBodyFloatData +public static final String btRigidBodyDataName = "btRigidBodyFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum btRigidBodyFlags */ +public static final int + BT_DISABLE_WORLD_GRAVITY = 1, + /**BT_ENABLE_GYROPSCOPIC_FORCE flags is enabled by default in Bullet 2.83 and onwards. + * and it BT_ENABLE_GYROPSCOPIC_FORCE becomes equivalent to BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY + * See Demos/GyroscopicDemo and computeGyroscopicImpulseImplicit */ + BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT = 2, + BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD = 4, + BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY = 8, + BT_ENABLE_GYROPSCOPIC_FORCE = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY; +// Targeting ../BulletDynamics/btRigidBody.java + + +// Targeting ../BulletDynamics/btRigidBodyFloatData.java + + +// Targeting ../BulletDynamics/btRigidBodyDoubleData.java + + + +// #endif //BT_RIGIDBODY_H + + +// Parsed from BulletDynamics/Dynamics/btDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DYNAMICS_WORLD_H +// #define BT_DYNAMICS_WORLD_H + +// #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" +// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +// Targeting ../BulletDynamics/btActionInterface.java + + +// Targeting ../BulletDynamics/btInternalTickCallback.java + + + +/** enum btDynamicsWorldType */ +public static final int + BT_SIMPLE_DYNAMICS_WORLD = 1, + BT_DISCRETE_DYNAMICS_WORLD = 2, + BT_CONTINUOUS_DYNAMICS_WORLD = 3, + BT_SOFT_RIGID_DYNAMICS_WORLD = 4, + BT_GPU_DYNAMICS_WORLD = 5, + BT_SOFT_MULTIBODY_DYNAMICS_WORLD = 6, + BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD = 7; +// Targeting ../BulletDynamics/btDynamicsWorld.java + + +// Targeting ../BulletDynamics/btDynamicsWorldDoubleData.java + + +// Targeting ../BulletDynamics/btDynamicsWorldFloatData.java + + + +// #endif //BT_DYNAMICS_WORLD_H + + +// Parsed from BulletDynamics/ConstraintSolver/btContactSolverInfo.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONTACT_SOLVER_INFO +// #define BT_CONTACT_SOLVER_INFO + +// #include "LinearMath/btScalar.h" + +/** enum btSolverMode */ +public static final int + SOLVER_RANDMIZE_ORDER = 1, + SOLVER_FRICTION_SEPARATE = 2, + SOLVER_USE_WARMSTARTING = 4, + SOLVER_USE_2_FRICTION_DIRECTIONS = 16, + SOLVER_ENABLE_FRICTION_DIRECTION_CACHING = 32, + SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION = 64, + SOLVER_CACHE_FRIENDLY = 128, + SOLVER_SIMD = 256, + SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS = 512, + SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS = 1024, + SOLVER_DISABLE_IMPLICIT_CONE_FRICTION = 2048, + SOLVER_USE_ARTICULATED_WARMSTARTING = 4096; +// Targeting ../BulletDynamics/btContactSolverInfoData.java + + +// Targeting ../BulletDynamics/btContactSolverInfo.java + + +// Targeting ../BulletDynamics/btContactSolverInfoDoubleData.java + + +// Targeting ../BulletDynamics/btContactSolverInfoFloatData.java + + + +// #endif //BT_CONTACT_SOLVER_INFO + + +// Parsed from BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DISCRETE_DYNAMICS_WORLD_H +// #define BT_DISCRETE_DYNAMICS_WORLD_H + +// #include "btDynamicsWorld.h" +// Targeting ../BulletDynamics/btSimulationIslandManager.java + + +// Targeting ../BulletDynamics/btPersistentManifold.java + + +// Targeting ../BulletDynamics/InplaceSolverIslandCallback.java + + + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btThreads.h" +// Targeting ../BulletDynamics/btDiscreteDynamicsWorld.java + + + +// #endif //BT_DISCRETE_DYNAMICS_WORLD_H + + +// Parsed from BulletDynamics/Dynamics/btSimpleDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMPLE_DYNAMICS_WORLD_H +// #define BT_SIMPLE_DYNAMICS_WORLD_H + +// #include "btDynamicsWorld.h" +// Targeting ../BulletDynamics/btSimpleDynamicsWorld.java + + + +// #endif //BT_SIMPLE_DYNAMICS_WORLD_H + + +// Parsed from BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_POINT2POINTCONSTRAINT_H +// #define BT_POINT2POINTCONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btPoint2PointConstraintData2 btPoint2PointConstraintFloatData +public static final String btPoint2PointConstraintDataName = "btPoint2PointConstraintFloatData"; +// Targeting ../BulletDynamics/btConstraintSetting.java + + + +/** enum btPoint2PointFlags */ +public static final int + BT_P2P_FLAGS_ERP = 1, + BT_P2P_FLAGS_CFM = 2; +// Targeting ../BulletDynamics/btPoint2PointConstraint.java + + +// Targeting ../BulletDynamics/btPoint2PointConstraintFloatData.java + + +// Targeting ../BulletDynamics/btPoint2PointConstraintDoubleData2.java + + +// Targeting ../BulletDynamics/btPoint2PointConstraintDoubleData.java + + +// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_POINT2POINTCONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btHingeConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* Hinge Constraint by Dirk Gregorius. Limits added by Marcus Hennix at Starbreeze Studios */ + +// #ifndef BT_HINGECONSTRAINT_H +// #define BT_HINGECONSTRAINT_H + +public static final int _BT_USE_CENTER_LIMIT_ = 1; + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btHingeConstraintData btHingeConstraintFloatData +public static final String btHingeConstraintDataName = "btHingeConstraintFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum btHingeFlags */ +public static final int + BT_HINGE_FLAGS_CFM_STOP = 1, + BT_HINGE_FLAGS_ERP_STOP = 2, + BT_HINGE_FLAGS_CFM_NORM = 4, + BT_HINGE_FLAGS_ERP_NORM = 8; +// Targeting ../BulletDynamics/btHingeConstraint.java + + +// Targeting ../BulletDynamics/btHingeConstraintDoubleData.java + + +// Targeting ../BulletDynamics/btHingeAccumulatedAngleConstraint.java + + +// Targeting ../BulletDynamics/btHingeConstraintFloatData.java + + +// Targeting ../BulletDynamics/btHingeConstraintDoubleData2.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_HINGECONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btConeTwistConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. + +Written by: Marcus Hennix +*/ + +/* +Overview: + +btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc). +It is a fixed translation, 3 degree-of-freedom (DOF) rotational "joint". +It divides the 3 rotational DOFs into swing (movement within a cone) and twist. +Swing is divided into swing1 and swing2 which can have different limits, giving an elliptical shape. +(Note: the cone's base isn't flat, so this ellipse is "embedded" on the surface of a sphere.) + +In the contraint's frame of reference: +twist is along the x-axis, +and swing 1 and 2 are along the z and y axes respectively. +*/ + +// #ifndef BT_CONETWISTCONSTRAINT_H +// #define BT_CONETWISTCONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btConeTwistConstraintData2 btConeTwistConstraintData +public static final String btConeTwistConstraintDataName = "btConeTwistConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum btConeTwistFlags */ +public static final int + BT_CONETWIST_FLAGS_LIN_CFM = 1, + BT_CONETWIST_FLAGS_LIN_ERP = 2, + BT_CONETWIST_FLAGS_ANG_CFM = 4; +// Targeting ../BulletDynamics/btConeTwistConstraint.java + + +// Targeting ../BulletDynamics/btConeTwistConstraintDoubleData.java + + +// Targeting ../BulletDynamics/btConeTwistConstraintData.java + + +// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION +// + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_CONETWISTCONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ + +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +// #ifndef BT_GENERIC_6DOF_CONSTRAINT_H +// #define BT_GENERIC_6DOF_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGeneric6DofConstraintData2 btGeneric6DofConstraintData +public static final String btGeneric6DofConstraintDataName = "btGeneric6DofConstraintData"; +// Targeting ../BulletDynamics/btRotationalLimitMotor.java + + +// Targeting ../BulletDynamics/btTranslationalLimitMotor.java + + + +/** enum bt6DofFlags */ +public static final int + BT_6DOF_FLAGS_CFM_NORM = 1, + BT_6DOF_FLAGS_CFM_STOP = 2, + BT_6DOF_FLAGS_ERP_STOP = 4; +public static final int BT_6DOF_FLAGS_AXIS_SHIFT = 3; +// Targeting ../BulletDynamics/btGeneric6DofConstraint.java + + +// Targeting ../BulletDynamics/btGeneric6DofConstraintData.java + + +// Targeting ../BulletDynamics/btGeneric6DofConstraintDoubleData2.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_GENERIC_6DOF_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btSliderConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +Added by Roman Ponomarev (rponom@gmail.com) +April 04, 2008 + +TODO: + - add clamping od accumulated impulse to improve stability + - add conversion for ODE constraint solver +*/ + +// #ifndef BT_SLIDER_CONSTRAINT_H +// #define BT_SLIDER_CONSTRAINT_H + +// #include "LinearMath/btScalar.h" //for BT_USE_DOUBLE_PRECISION + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btSliderConstraintData2 btSliderConstraintData +public static final String btSliderConstraintDataName = "btSliderConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_SOFTNESS(); +public static final double SLIDER_CONSTRAINT_DEF_SOFTNESS = SLIDER_CONSTRAINT_DEF_SOFTNESS(); +public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_DAMPING(); +public static final double SLIDER_CONSTRAINT_DEF_DAMPING = SLIDER_CONSTRAINT_DEF_DAMPING(); +public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_RESTITUTION(); +public static final double SLIDER_CONSTRAINT_DEF_RESTITUTION = SLIDER_CONSTRAINT_DEF_RESTITUTION(); +public static native @MemberGetter double SLIDER_CONSTRAINT_DEF_CFM(); +public static final double SLIDER_CONSTRAINT_DEF_CFM = SLIDER_CONSTRAINT_DEF_CFM(); + +/** enum btSliderFlags */ +public static final int + BT_SLIDER_FLAGS_CFM_DIRLIN = (1 << 0), + BT_SLIDER_FLAGS_ERP_DIRLIN = (1 << 1), + BT_SLIDER_FLAGS_CFM_DIRANG = (1 << 2), + BT_SLIDER_FLAGS_ERP_DIRANG = (1 << 3), + BT_SLIDER_FLAGS_CFM_ORTLIN = (1 << 4), + BT_SLIDER_FLAGS_ERP_ORTLIN = (1 << 5), + BT_SLIDER_FLAGS_CFM_ORTANG = (1 << 6), + BT_SLIDER_FLAGS_ERP_ORTANG = (1 << 7), + BT_SLIDER_FLAGS_CFM_LIMLIN = (1 << 8), + BT_SLIDER_FLAGS_ERP_LIMLIN = (1 << 9), + BT_SLIDER_FLAGS_CFM_LIMANG = (1 << 10), + BT_SLIDER_FLAGS_ERP_LIMANG = (1 << 11); +// Targeting ../BulletDynamics/btSliderConstraint.java + + +// Targeting ../BulletDynamics/btSliderConstraintData.java + + +// Targeting ../BulletDynamics/btSliderConstraintDoubleData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_SLIDER_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H +// #define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btTypedConstraint.h" +// #include "btGeneric6DofConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData +public static final String btGeneric6DofSpringConstraintDataName = "btGeneric6DofSpringConstraintData"; +// Targeting ../BulletDynamics/btGeneric6DofSpringConstraint.java + + +// Targeting ../BulletDynamics/btGeneric6DofSpringConstraintData.java + + +// Targeting ../BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer +Pros: +- Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled) +- Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring) +- Servo motor functionality +- Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision) +- Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2) + +Cons: +- It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation. +- At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.) +*/ + +/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ + +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +// #ifndef BT_GENERIC_6DOF_CONSTRAINT2_H +// #define BT_GENERIC_6DOF_CONSTRAINT2_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData +public static final String btGeneric6DofSpring2ConstraintDataName = "btGeneric6DofSpring2ConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum RotateOrder */ +public static final int + RO_XYZ = 0, + RO_XZY = 1, + RO_YXZ = 2, + RO_YZX = 3, + RO_ZXY = 4, + RO_ZYX = 5; +// Targeting ../BulletDynamics/btRotationalLimitMotor2.java + + +// Targeting ../BulletDynamics/btTranslationalLimitMotor2.java + + + +/** enum bt6DofFlags2 */ +public static final int + BT_6DOF_FLAGS_CFM_STOP2 = 1, + BT_6DOF_FLAGS_ERP_STOP2 = 2, + BT_6DOF_FLAGS_CFM_MOTO2 = 4, + BT_6DOF_FLAGS_ERP_MOTO2 = 8, + BT_6DOF_FLAGS_USE_INFINITE_ERROR = (1<<16); +public static final int BT_6DOF_FLAGS_AXIS_SHIFT2 = 4; +// Targeting ../BulletDynamics/btGeneric6DofSpring2Constraint.java + + +// Targeting ../BulletDynamics/btGeneric6DofSpring2ConstraintData.java + + +// Targeting ../BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java + + + + + + + +// #endif //BT_GENERIC_6DOF_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btUniversalConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_UNIVERSAL_CONSTRAINT_H +// #define BT_UNIVERSAL_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btTypedConstraint.h" +// #include "btGeneric6DofConstraint.h" +// Targeting ../BulletDynamics/btUniversalConstraint.java + + + +// #endif // BT_UNIVERSAL_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btHinge2Constraint.h + +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_HINGE2_CONSTRAINT_H +// #define BT_HINGE2_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btTypedConstraint.h" +// #include "btGeneric6DofSpring2Constraint.h" +// Targeting ../BulletDynamics/btHinge2Constraint.java + + + +// #endif // BT_HINGE2_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGearConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2012 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GEAR_CONSTRAINT_H +// #define BT_GEAR_CONSTRAINT_H + +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGearConstraintData btGearConstraintFloatData +public static final String btGearConstraintDataName = "btGearConstraintFloatData"; +// Targeting ../BulletDynamics/btGearConstraint.java + + +// Targeting ../BulletDynamics/btGearConstraintFloatData.java + + +// Targeting ../BulletDynamics/btGearConstraintDoubleData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_GEAR_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btFixedConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_FIXED_CONSTRAINT_H +// #define BT_FIXED_CONSTRAINT_H + +// #include "btGeneric6DofSpring2Constraint.h" +// Targeting ../BulletDynamics/btFixedConstraint.java + + + +// #endif //BT_FIXED_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btConstraintSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONSTRAINT_SOLVER_H +// #define BT_CONSTRAINT_SOLVER_H + +// #include "LinearMath/btScalar.h" +// Targeting ../BulletDynamics/btStackAlloc.java + + +/** btConstraintSolver provides solver interface */ + +/** enum btConstraintSolverType */ +public static final int + BT_SEQUENTIAL_IMPULSE_SOLVER = 1, + BT_MLCP_SOLVER = 2, + BT_NNCG_SOLVER = 4, + BT_MULTIBODY_SOLVER = 8, + BT_BLOCK_SOLVER = 16; +// Targeting ../BulletDynamics/btConstraintSolver.java + + + +// #endif //BT_CONSTRAINT_SOLVER_H + + +// Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H +// #define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" +// #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" +// #include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" +// #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" +// Targeting ../BulletDynamics/btSolverAnalyticsData.java + + +// Targeting ../BulletDynamics/btSequentialImpulseConstraintSolver.java + + + +// #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H + + +// Parsed from BulletDynamics/Vehicle/btVehicleRaycaster.h + +/* + * Copyright (c) 2005 Erwin Coumans http://bulletphysics.org + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies. + * Erwin Coumans makes no representations about the suitability + * of this software for any purpose. + * It is provided "as is" without express or implied warranty. +*/ +// #ifndef BT_VEHICLE_RAYCASTER_H +// #define BT_VEHICLE_RAYCASTER_H + +// #include "LinearMath/btVector3.h" +// Targeting ../BulletDynamics/btVehicleRaycaster.java + + + +// #endif //BT_VEHICLE_RAYCASTER_H + + +// Parsed from BulletDynamics/Vehicle/btWheelInfo.h + +/* + * Copyright (c) 2005 Erwin Coumans https://bulletphysics.org + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies. + * Erwin Coumans makes no representations about the suitability + * of this software for any purpose. + * It is provided "as is" without express or implied warranty. +*/ +// #ifndef BT_WHEEL_INFO_H +// #define BT_WHEEL_INFO_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// Targeting ../BulletDynamics/btWheelInfoConstructionInfo.java + + +// Targeting ../BulletDynamics/btWheelInfo.java + + + +// #endif //BT_WHEEL_INFO_H + + +// Parsed from BulletDynamics/Vehicle/btRaycastVehicle.h + +/* + * Copyright (c) 2005 Erwin Coumans https://bulletphysics.org + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies. + * Erwin Coumans makes no representations about the suitability + * of this software for any purpose. + * It is provided "as is" without express or implied warranty. +*/ +// #ifndef BT_RAYCASTVEHICLE_H +// #define BT_RAYCASTVEHICLE_H + +// #include "BulletDynamics/Dynamics/btRigidBody.h" +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +// #include "btVehicleRaycaster.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btWheelInfo.h" +// #include "BulletDynamics/Dynamics/btActionInterface.h" +// Targeting ../BulletDynamics/btRaycastVehicle.java + + +// Targeting ../BulletDynamics/btDefaultVehicleRaycaster.java + + + +// #endif //BT_RAYCASTVEHICLE_H + + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java new file mode 100644 index 00000000000..fda4565d056 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -0,0 +1,992 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.global; + +import org.bytedeco.bullet.LinearMath.*; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +public class LinearMath extends org.bytedeco.bullet.presets.LinearMath { + static { Loader.load(); } + +// Parsed from LinearMath/btScalar.h + +/* +Copyright (c) 2003-2009 Erwin Coumans http://bullet.googlecode.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SCALAR_H +// #define BT_SCALAR_H + +// #ifdef BT_MANAGED_CODE +//Aligned data types not supported in managed code +// #pragma unmanaged +// #endif + +// #include +// #include //size_t for MSVC 6.0 +// #include + +/* SVN $Revision$ on $Date$ from http://bullet.googlecode.com*/ +public static final int BT_BULLET_VERSION = 320; + +public static native int btGetVersion(); + +public static native int btIsDoublePrecision(); + + +// The following macro "BT_NOT_EMPTY_FILE" can be put into a file +// in order suppress the MS Visual C++ Linker warning 4221 +// +// warning LNK4221: no public symbols found; archive member will be inaccessible +// +// This warning occurs on PC and XBOX when a file compiles out completely +// has no externally visible symbols which may be dependant on configuration +// #defines and options. +// +// see more https://stackoverflow.com/questions/1822887/what-is-the-best-way-to-eliminate-ms-visual-c-linker-warning-warning-lnk422 + +// #if defined(_MSC_VER) +// #else +// #define BT_NOT_EMPTY_FILE +// #endif + +// clang and most formatting tools don't support indentation of preprocessor guards, so turn it off +// clang-format off +// #if defined(DEBUG) || defined (_DEBUG) +// #endif + +// #ifdef _WIN32 + +// #else//_WIN32 + +// #if defined (__CELLOS_LV2__) + +// #else//defined (__CELLOS_LV2__) + +// #ifdef USE_LIBSPE2 + + +// #else//USE_LIBSPE2 + //non-windows systems + +// #if (defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION))) + +// #else//__APPLE__ + +// #define SIMD_FORCE_INLINE inline + /**\todo: check out alignment methods for other platforms/compilers + * #define ATTRIBUTE_ALIGNED16(a) a __attribute__ ((aligned (16))) + * #define ATTRIBUTE_ALIGNED64(a) a __attribute__ ((aligned (64))) + * #define ATTRIBUTE_ALIGNED128(a) a __attribute__ ((aligned (128))) */ +// #define ATTRIBUTE_ALIGNED16(a) a +// #define ATTRIBUTE_ALIGNED64(a) a +// #define ATTRIBUTE_ALIGNED128(a) a +// #ifndef assert +// #include +// #endif + +// #if defined(DEBUG) || defined (_DEBUG) +// #else +// #define btAssert(x) +// #endif + + //btFullAssert is optional, slows down a lot +// #define btFullAssert(x) +// #define btLikely(_c) _c +// #define btUnlikely(_c) _c +// #endif //__APPLE__ +// #endif // LIBSPE2 +// #endif //__CELLOS_LV2__ +// #endif//_WIN32 + + +/**The btScalar type abstracts floating point numbers, to easily switch between double and single floating point precision. */ +// #if defined(BT_USE_DOUBLE_PRECISION) +// #else + //keep BT_LARGE_FLOAT*BT_LARGE_FLOAT < FLT_MAX + public static final double BT_LARGE_FLOAT = 1e18f; +// Targeting ../LinearMath/btInfMaskConverter.java + + + public static native @ByRef btInfMaskConverter btInfinityMask(); public static native void btInfinityMask(btInfMaskConverter setter); +// #define BT_INFINITY (btInfinityMask.mask) + public static native int btGetInfinityMask(); +// #endif +// #endif //BT_USE_NEON + +// #endif //BT_USE_SSE + +// #ifdef BT_USE_NEON +// #endif//BT_USE_NEON + +// #define BT_DECLARE_ALIGNED_ALLOCATOR() +// SIMD_FORCE_INLINE void *operator new(size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } +// SIMD_FORCE_INLINE void operator delete(void *ptr) { btAlignedFree(ptr); } +// SIMD_FORCE_INLINE void *operator new(size_t, void *ptr) { return ptr; } +// SIMD_FORCE_INLINE void operator delete(void *, void *) {} +// SIMD_FORCE_INLINE void *operator new[](size_t sizeInBytes) { return btAlignedAlloc(sizeInBytes, 16); } +// SIMD_FORCE_INLINE void operator delete[](void *ptr) { btAlignedFree(ptr); } +// SIMD_FORCE_INLINE void *operator new[](size_t, void *ptr) { return ptr; } +// SIMD_FORCE_INLINE void operator delete[](void *, void *) {} + +// #if defined(BT_USE_DOUBLE_PRECISION) || defined(BT_FORCE_DOUBLE_FUNCTIONS) + + public static native @Cast("btScalar") float btSqrt(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btFabs(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btCos(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btSin(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btTan(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btAcos(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btAsin(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btAtan(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btAtan2(@Cast("btScalar") float x, @Cast("btScalar") float y); + public static native @Cast("btScalar") float btExp(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btLog(@Cast("btScalar") float x); + public static native @Cast("btScalar") float btPow(@Cast("btScalar") float x, @Cast("btScalar") float y); + public static native @Cast("btScalar") float btFmod(@Cast("btScalar") float x, @Cast("btScalar") float y); + +// #else//BT_USE_DOUBLE_PRECISION + +// #endif//BT_USE_DOUBLE_PRECISION + +public static native @MemberGetter double SIMD_PI(); +public static final double SIMD_PI = SIMD_PI(); +public static native @MemberGetter double SIMD_2_PI(); +public static final double SIMD_2_PI = SIMD_2_PI(); +public static native @MemberGetter double SIMD_HALF_PI(); +public static final double SIMD_HALF_PI = SIMD_HALF_PI(); +public static native @MemberGetter double SIMD_RADS_PER_DEG(); +public static final double SIMD_RADS_PER_DEG = SIMD_RADS_PER_DEG(); +public static native @MemberGetter double SIMD_DEGS_PER_RAD(); +public static final double SIMD_DEGS_PER_RAD = SIMD_DEGS_PER_RAD(); +public static native @MemberGetter double SIMDSQRT12(); +public static final double SIMDSQRT12 = SIMDSQRT12(); +// #define btRecipSqrt(x) ((btScalar)(btScalar(1.0) / btSqrt(btScalar(x)))) /* reciprocal square root */ +// #define btRecip(x) (btScalar(1.0) / btScalar(x)) + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define SIMD_EPSILON FLT_EPSILON +// #define SIMD_INFINITY FLT_MAX + public static final double BT_ONE = 1.0f; + public static final double BT_ZERO = 0.0f; + public static final double BT_TWO = 2.0f; + public static final double BT_HALF = 0.5f; +// #endif + +// clang-format on + +public static native @Cast("btScalar") float btAtan2Fast(@Cast("btScalar") float y, @Cast("btScalar") float x); + +public static native @Cast("bool") boolean btFuzzyZero(@Cast("btScalar") float x); + +public static native @Cast("bool") boolean btEqual(@Cast("btScalar") float a, @Cast("btScalar") float eps); +public static native @Cast("bool") boolean btGreaterEqual(@Cast("btScalar") float a, @Cast("btScalar") float eps); + +public static native int btIsNegative(@Cast("btScalar") float x); + +public static native @Cast("btScalar") float btRadians(@Cast("btScalar") float x); +public static native @Cast("btScalar") float btDegrees(@Cast("btScalar") float x); + +// #define BT_DECLARE_HANDLE(name) +// typedef struct name##__ +// { +// int unused; +// } * name + +// #ifndef btFsel +public static native @Cast("btScalar") float btFsel(@Cast("btScalar") float a, @Cast("btScalar") float b, @Cast("btScalar") float c); +// #endif +// #define btFsels(a, b, c) (btScalar) btFsel(a, b, c) + +public static native @Cast("bool") boolean btMachineIsLittleEndian(); + +/**btSelect avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360 + * Thanks Phil Knight. See also http://www.cellperformance.com/articles/2006/04/more_techniques_for_eliminatin_1.html */ +public static native @Cast("unsigned") int btSelect(@Cast("unsigned") int condition, @Cast("unsigned") int valueIfConditionNonZero, @Cast("unsigned") int valueIfConditionZero); +public static native float btSelect(@Cast("unsigned") int condition, float valueIfConditionNonZero, float valueIfConditionZero); + +//PCK: endian swapping functions +public static native @Cast("unsigned") int btSwapEndian(@Cast("unsigned") int val); + +public static native @Cast("unsigned short") short btSwapEndian(@Cast("unsigned short") short val); + +/**btSwapFloat uses using char pointers to swap the endianness +////btSwapFloat/btSwapDouble will NOT return a float, because the machine might 'correct' invalid floating point values + * Not all values of sign/exponent/mantissa are valid floating point numbers according to IEEE 754. + * When a floating point unit is faced with an invalid value, it may actually change the value, or worse, throw an exception. + * In most systems, running user mode code, you wouldn't get an exception, but instead the hardware/os/runtime will 'fix' the number for you. + * so instead of returning a float/double, we return integer/long long integer */ +public static native @Cast("unsigned int") int btSwapEndianFloat(float d); + +// unswap using char pointers +public static native float btUnswapEndianFloat(@Cast("unsigned int") int a); + +// swap using char pointers +public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") BytePointer dst); +public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") ByteBuffer dst); +public static native void btSwapEndianDouble(double d, @Cast("unsigned char*") byte[] dst); + +// unswap using char pointers +public static native double btUnswapEndianDouble(@Cast("const unsigned char*") BytePointer src); +public static native double btUnswapEndianDouble(@Cast("const unsigned char*") ByteBuffer src); +public static native double btUnswapEndianDouble(@Cast("const unsigned char*") byte[] src); + +public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") FloatPointer a, @Cast("const btScalar*") FloatPointer b, int n); +public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") FloatBuffer a, @Cast("const btScalar*") FloatBuffer b, int n); +public static native @Cast("btScalar") float btLargeDot(@Cast("const btScalar*") float[] a, @Cast("const btScalar*") float[] b, int n); + +// returns normalized value in range [-SIMD_PI, SIMD_PI] +public static native @Cast("btScalar") float btNormalizeAngle(@Cast("btScalar") float angleInRadians); +// Targeting ../LinearMath/btTypedObject.java + + + +/**align a pointer to the provided alignment, upwards */ + +// #endif //BT_SCALAR_H + + +// Parsed from LinearMath/btVector3.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_VECTOR3_H +// #define BT_VECTOR3_H + +//#include +// #include "btScalar.h" +// #include "btMinMax.h" +// #include "btAlignedAllocator.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btVector3Data btVector3FloatData +public static final String btVector3DataName = "btVector3FloatData"; +// Targeting ../LinearMath/btVector3.java + + + +/**\brief Return the sum of two vectors (Point symantics)*/ +public static native @ByVal @Name("operator +") btVector3 add(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the elementwise product of two vectors */ +public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the difference between two vectors */ +public static native @ByVal @Name("operator -") btVector3 subtract(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the negative of the vector */ +public static native @ByVal @Name("operator -") btVector3 subtract(@Const @ByRef btVector3 v); + +/**\brief Return the vector scaled by s */ +public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v, @Cast("const btScalar") float s); + +/**\brief Return the vector scaled by s */ +public static native @ByVal @Name("operator *") btVector3 multiply(@Cast("const btScalar") float s, @Const @ByRef btVector3 v); + +/**\brief Return the vector inversely scaled by s */ +public static native @ByVal @Name("operator /") btVector3 divide(@Const @ByRef btVector3 v, @Cast("const btScalar") float s); + +/**\brief Return the vector inversely scaled by s */ +public static native @ByVal @Name("operator /") btVector3 divide(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the dot product between two vectors */ +public static native @Cast("btScalar") float btDot(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the distance squared between two vectors */ +public static native @Cast("btScalar") float btDistance2(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the distance between two vectors */ +public static native @Cast("btScalar") float btDistance(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the angle between two vectors */ +public static native @Cast("btScalar") float btAngle(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +/**\brief Return the cross product of two vectors */ +public static native @ByVal btVector3 btCross(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); + +public static native @Cast("btScalar") float btTriple(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Const @ByRef btVector3 v3); + +/**\brief Return the linear interpolation between two vectors + * @param v1 One vector + * @param v2 The other vector + * @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */ +public static native @ByVal btVector3 lerp(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Cast("const btScalar") float t); + + + + + + + + + + + + +// Targeting ../LinearMath/btVector4.java + + + +/**btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef FloatPointer destVal); +public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef FloatBuffer destVal); +public static native void btSwapScalarEndian(@Cast("const btScalar") float sourceVal, @Cast("btScalar*") @ByRef float[] destVal); +/**btSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void btSwapVector3Endian(@Const @ByRef btVector3 sourceVec, @ByRef btVector3 destVec); + +/**btUnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void btUnSwapVector3Endian(@ByRef btVector3 vector); +// Targeting ../LinearMath/btVector3FloatData.java + + +// Targeting ../LinearMath/btVector3DoubleData.java + + + + + + + + + + + + + + + + + +// #endif //BT_VECTOR3_H + + +// Parsed from LinearMath/btQuadWord.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMD_QUADWORD_H +// #define BT_SIMD_QUADWORD_H + +// #include "btScalar.h" +// #include "btMinMax.h" + +// #if defined(__CELLOS_LV2) && defined(__SPU__) +// #include +// Targeting ../LinearMath/btQuadWord.java + + + +// #endif //BT_SIMD_QUADWORD_H + + +// Parsed from LinearMath/btQuaternion.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMD__QUATERNION_H_ +// #define BT_SIMD__QUATERNION_H_ + +// #include "btVector3.h" +// #include "btQuadWord.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btQuaternionData btQuaternionFloatData +public static final String btQuaternionDataName = "btQuaternionFloatData"; +// Targeting ../LinearMath/btQuaternion.java + + + +/**\brief Return the product of two quaternions */ +public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); + +public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btQuaternion q, @Const @ByRef btVector3 w); + +public static native @ByVal @Name("operator *") btQuaternion multiply(@Const @ByRef btVector3 w, @Const @ByRef btQuaternion q); + +/**\brief Calculate the dot product between two quaternions */ +public static native @Cast("btScalar") float dot(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); + +/**\brief Return the length of a quaternion */ +public static native @Cast("btScalar") float length(@Const @ByRef btQuaternion q); + +/**\brief Return the angle between two quaternions*/ +public static native @Cast("btScalar") float btAngle(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2); + +/**\brief Return the inverse of a quaternion*/ +public static native @ByVal btQuaternion inverse(@Const @ByRef btQuaternion q); + +/**\brief Return the result of spherical linear interpolation betwen two quaternions + * @param q1 The first quaternion + * @param q2 The second quaternion + * @param t The ration between q1 and q2. t = 0 return q1, t=1 returns q2 + * Slerp assumes constant velocity between positions. */ +public static native @ByVal btQuaternion slerp(@Const @ByRef btQuaternion q1, @Const @ByRef btQuaternion q2, @Cast("const btScalar") float t); + +public static native @ByVal btVector3 quatRotate(@Const @ByRef btQuaternion rotation, @Const @ByRef btVector3 v); + +public static native @ByVal btQuaternion shortestArcQuat(@Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1); + +public static native @ByVal btQuaternion shortestArcQuatNormalize2(@ByRef btVector3 v0, @ByRef btVector3 v1); +// Targeting ../LinearMath/btQuaternionFloatData.java + + +// Targeting ../LinearMath/btQuaternionDoubleData.java + + + + + + + + + + + + + + + + + +// #endif //BT_SIMD__QUATERNION_H_ + + +// Parsed from LinearMath/btMatrix3x3.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MATRIX3x3_H +// #define BT_MATRIX3x3_H + +// #include "btVector3.h" +// #include "btQuaternion.h" +// #include + +// #ifdef BT_USE_SSE +// #endif + +// #if defined(BT_USE_SSE) +// #elif defined(BT_USE_NEON) +// #endif + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btMatrix3x3Data btMatrix3x3FloatData +// Targeting ../LinearMath/btMatrix3x3.java + + + + + + + +public static native @ByVal @Name("operator *") btMatrix3x3 multiply(@Const @ByRef btMatrix3x3 m, @Cast("const btScalar") float k); + +public static native @ByVal @Name("operator +") btMatrix3x3 add(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); + +public static native @ByVal @Name("operator -") btMatrix3x3 subtract(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); + + + + + + + + + + + + + + + + + +public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btMatrix3x3 m, @Const @ByRef btVector3 v); + +public static native @ByVal @Name("operator *") btVector3 multiply(@Const @ByRef btVector3 v, @Const @ByRef btMatrix3x3 m); + +public static native @ByVal @Name("operator *") btMatrix3x3 multiply(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); + +/* +SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const btMatrix3x3& m2) { +return btMatrix3x3( +m1[0][0] * m2[0][0] + m1[1][0] * m2[1][0] + m1[2][0] * m2[2][0], +m1[0][0] * m2[0][1] + m1[1][0] * m2[1][1] + m1[2][0] * m2[2][1], +m1[0][0] * m2[0][2] + m1[1][0] * m2[1][2] + m1[2][0] * m2[2][2], +m1[0][1] * m2[0][0] + m1[1][1] * m2[1][0] + m1[2][1] * m2[2][0], +m1[0][1] * m2[0][1] + m1[1][1] * m2[1][1] + m1[2][1] * m2[2][1], +m1[0][1] * m2[0][2] + m1[1][1] * m2[1][2] + m1[2][1] * m2[2][2], +m1[0][2] * m2[0][0] + m1[1][2] * m2[1][0] + m1[2][2] * m2[2][0], +m1[0][2] * m2[0][1] + m1[1][2] * m2[1][1] + m1[2][2] * m2[2][1], +m1[0][2] * m2[0][2] + m1[1][2] * m2[1][2] + m1[2][2] * m2[2][2]); +} +*/ + +/**\brief Equality operator between two matrices +* It will test all elements are equal. */ +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btMatrix3x3 m1, @Const @ByRef btMatrix3x3 m2); +// Targeting ../LinearMath/btMatrix3x3FloatData.java + + +// Targeting ../LinearMath/btMatrix3x3DoubleData.java + + + + + + + + + + + + + +// #endif //BT_MATRIX3x3_H + + +// Parsed from LinearMath/btTransform.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRANSFORM_H +// #define BT_TRANSFORM_H + +// #include "btMatrix3x3.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btTransformData btTransformFloatData +// Targeting ../LinearMath/btTransform.java + + + + + + + + + +/**\brief Test if two transforms have all elements equal */ +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btTransform t1, @Const @ByRef btTransform t2); +// Targeting ../LinearMath/btTransformFloatData.java + + +// Targeting ../LinearMath/btTransformDoubleData.java + + + + + + + + + + + + + +// #endif //BT_TRANSFORM_H + + +// Parsed from LinearMath/btAlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBJECT_ARRAY__ +// #define BT_OBJECT_ARRAY__ + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +// #include "btAlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW + * then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int BT_USE_PLACEMENT_NEW = 1; +//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef BT_USE_MEMCPY +// #include +// #include +// #endif //BT_USE_MEMCPY + +// #ifdef BT_USE_PLACEMENT_NEW +// #include +// Targeting ../LinearMath/btAlignedObjectArray_btVector3.java + + +// Targeting ../LinearMath/btAlignedObjectArray_btScalar.java + + + +// #endif //BT_OBJECT_ARRAY__ + + +// Parsed from LinearMath/btHashMap.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_HASH_MAP_H +// #define BT_HASH_MAP_H + +// #include +// #include "btAlignedObjectArray.h" +// Targeting ../LinearMath/btHashString.java + + + +@MemberGetter public static native int BT_HASH_NULL(); +// Targeting ../LinearMath/btHashInt.java + + +// Targeting ../LinearMath/btHashPtr.java + + +// Targeting ../LinearMath/btHashMap_btHashPtr_voidPointer.java + + + +// #endif //BT_HASH_MAP_H + + +// Parsed from LinearMath/btSerializer.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SERIALIZER_H +// #define BT_SERIALIZER_H + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +// #include "btHashMap.h" + +// #if !defined(__CELLOS_LV2__) && !defined(__MWERKS__) +// #include +// #endif +// #include + +public static native @Cast("char") byte sBulletDNAstr(int i); public static native void sBulletDNAstr(int i, byte setter); +@MemberGetter public static native @Cast("char*") BytePointer sBulletDNAstr(); +public static native int sBulletDNAlen(); public static native void sBulletDNAlen(int setter); +public static native @Cast("char") byte sBulletDNAstr64(int i); public static native void sBulletDNAstr64(int i, byte setter); +@MemberGetter public static native @Cast("char*") BytePointer sBulletDNAstr64(); +public static native int sBulletDNAlen64(); public static native void sBulletDNAlen64(int setter); + +public static native int btStrLen(@Cast("const char*") BytePointer str); +public static native int btStrLen(String str); +// Targeting ../LinearMath/btChunk.java + + + +/** enum btSerializationFlags */ +public static final int + BT_SERIALIZE_NO_BVH = 1, + BT_SERIALIZE_NO_TRIANGLEINFOMAP = 2, + BT_SERIALIZE_NO_DUPLICATE_ASSERT = 4, + BT_SERIALIZE_CONTACT_MANIFOLDS = 8; +// Targeting ../LinearMath/btSerializer.java + + + +public static final int BT_HEADER_LENGTH = 12; +// #if defined(__sgi) || defined(__sparc) || defined(__sparc__) || defined(__PPC__) || defined(__ppc__) || defined(__BIG_ENDIAN__) +// #define BT_MAKE_ID(a, b, c, d) ((int)(a) << 24 | (int)(b) << 16 | (c) << 8 | (d)) +// #else +// #define BT_MAKE_ID(a, b, c, d) ((int)(d) << 24 | (int)(c) << 16 | (b) << 8 | (a)) +// #endif + +public static native @MemberGetter int BT_MULTIBODY_CODE(); +public static final int BT_MULTIBODY_CODE = BT_MULTIBODY_CODE(); +public static native @MemberGetter int BT_MB_LINKCOLLIDER_CODE(); +public static final int BT_MB_LINKCOLLIDER_CODE = BT_MB_LINKCOLLIDER_CODE(); +public static native @MemberGetter int BT_SOFTBODY_CODE(); +public static final int BT_SOFTBODY_CODE = BT_SOFTBODY_CODE(); +public static native @MemberGetter int BT_COLLISIONOBJECT_CODE(); +public static final int BT_COLLISIONOBJECT_CODE = BT_COLLISIONOBJECT_CODE(); +public static native @MemberGetter int BT_RIGIDBODY_CODE(); +public static final int BT_RIGIDBODY_CODE = BT_RIGIDBODY_CODE(); +public static native @MemberGetter int BT_CONSTRAINT_CODE(); +public static final int BT_CONSTRAINT_CODE = BT_CONSTRAINT_CODE(); +public static native @MemberGetter int BT_BOXSHAPE_CODE(); +public static final int BT_BOXSHAPE_CODE = BT_BOXSHAPE_CODE(); +public static native @MemberGetter int BT_QUANTIZED_BVH_CODE(); +public static final int BT_QUANTIZED_BVH_CODE = BT_QUANTIZED_BVH_CODE(); +public static native @MemberGetter int BT_TRIANLGE_INFO_MAP(); +public static final int BT_TRIANLGE_INFO_MAP = BT_TRIANLGE_INFO_MAP(); +public static native @MemberGetter int BT_SHAPE_CODE(); +public static final int BT_SHAPE_CODE = BT_SHAPE_CODE(); +public static native @MemberGetter int BT_ARRAY_CODE(); +public static final int BT_ARRAY_CODE = BT_ARRAY_CODE(); +public static native @MemberGetter int BT_SBMATERIAL_CODE(); +public static final int BT_SBMATERIAL_CODE = BT_SBMATERIAL_CODE(); +public static native @MemberGetter int BT_SBNODE_CODE(); +public static final int BT_SBNODE_CODE = BT_SBNODE_CODE(); +public static native @MemberGetter int BT_DYNAMICSWORLD_CODE(); +public static final int BT_DYNAMICSWORLD_CODE = BT_DYNAMICSWORLD_CODE(); +public static native @MemberGetter int BT_CONTACTMANIFOLD_CODE(); +public static final int BT_CONTACTMANIFOLD_CODE = BT_CONTACTMANIFOLD_CODE(); +public static native @MemberGetter int BT_DNA_CODE(); +public static final int BT_DNA_CODE = BT_DNA_CODE(); +// Targeting ../LinearMath/btPointerUid.java + + +// Targeting ../LinearMath/btDefaultSerializer.java + + + +/**In general it is best to use btDefaultSerializer, + * in particular when writing the data to disk or sending it over the network. + * The btInMemorySerializer is experimental and only suitable in a few cases. + * The btInMemorySerializer takes a shortcut and can be useful to create a deep-copy + * of objects. There will be a demo on how to use the btInMemorySerializer. */ +// #ifdef ENABLE_INMEMORY_SERIALIZER +// #endif //ENABLE_INMEMORY_SERIALIZER + +// #endif //BT_SERIALIZER_H + + +// Parsed from LinearMath/btIDebugDraw.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_IDEBUG_DRAW__H +// #define BT_IDEBUG_DRAW__H + +// #include "btVector3.h" +// #include "btTransform.h" +// Targeting ../LinearMath/btIDebugDraw.java + + + +// #endif //BT_IDEBUG_DRAW__H + + +// Parsed from LinearMath/btQuickprof.h + + +/*************************************************************************************************** +** +** Real-Time Hierarchical Profiling for Game Programming Gems 3 +** +** by Greg Hjelstrom & Byon Garrabrant +** +***************************************************************************************************/ + +// Credits: The Clock class was inspired by the Timer classes in +// Ogre (www.ogre3d.org). + +// #ifndef BT_QUICK_PROF_H +// #define BT_QUICK_PROF_H + +// #include "btScalar.h" +public static final int USE_BT_CLOCK = 1; +// Targeting ../LinearMath/btClock.java + + +// Targeting ../LinearMath/btEnterProfileZoneFunc.java + + +// Targeting ../LinearMath/btLeaveProfileZoneFunc.java + + + +public static native btEnterProfileZoneFunc btGetCurrentEnterProfileZoneFunc(); +public static native btLeaveProfileZoneFunc btGetCurrentLeaveProfileZoneFunc(); + +public static native void btSetCustomEnterProfileZoneFunc(btEnterProfileZoneFunc enterFunc); +public static native void btSetCustomLeaveProfileZoneFunc(btLeaveProfileZoneFunc leaveFunc); + +// #ifndef BT_ENABLE_PROFILE +public static final int BT_NO_PROFILE = 1; +// #endif //BT_NO_PROFILE + +@MemberGetter public static native @Cast("const unsigned int") int BT_QUICKPROF_MAX_THREAD_COUNT(); + +//btQuickprofGetCurrentThreadIndex will return -1 if thread index cannot be determined, +//otherwise returns thread index in range [0..maxThreads] +public static native @Cast("unsigned int") int btQuickprofGetCurrentThreadIndex2(); +// Targeting ../LinearMath/CProfileSample.java + + + +// #define BT_PROFILE(name) CProfileSample __profile(name) + +// #endif //BT_QUICK_PROF_H + + +// Parsed from LinearMath/btMotionState.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MOTIONSTATE_H +// #define BT_MOTIONSTATE_H + +// #include "btTransform.h" +// Targeting ../LinearMath/btMotionState.java + + + +// #endif //BT_MOTIONSTATE_H + + +// Parsed from LinearMath/btDefaultMotionState.h + +// #ifndef BT_DEFAULT_MOTION_STATE_H +// #define BT_DEFAULT_MOTION_STATE_H + +// #include "btMotionState.h" +// Targeting ../LinearMath/btDefaultMotionState.java + + + +// #endif //BT_DEFAULT_MOTION_STATE_H + + +} diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 5da065a4208..52d3742b92d 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -62,7 +62,8 @@ link = "BulletCollision" ) }, - target = "org.bytedeco.bullet.BulletCollision" + target = "org.bytedeco.bullet.BulletCollision", + global = "org.bytedeco.bullet.global.BulletCollision" ) public class BulletCollision implements InfoMapper { static { Loader.checkVersion("org.bytedeco", "bullet"); } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index 129fd597fd5..94ed183cab9 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -39,7 +39,8 @@ link = "BulletDynamics" ) }, - target = "org.bytedeco.bullet.BulletDynamics" + target = "org.bytedeco.bullet.BulletDynamics", + global = "org.bytedeco.bullet.global.BulletDynamics" ) public class BulletDynamics implements InfoMapper { static { Loader.checkVersion("org.bytedeco", "bullet"); } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 4e116bea1b5..6ef5f5c58ef 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -30,7 +30,8 @@ link = "LinearMath" ) }, - target = "org.bytedeco.bullet.LinearMath" + target = "org.bytedeco.bullet.LinearMath", + global = "org.bytedeco.bullet.global.LinearMath" ) public class LinearMath implements InfoMapper { static { Loader.checkVersion("org.bytedeco", "bullet"); } diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index c38d97bbe47..3162158be92 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -1,5 +1,6 @@ module org.bytedeco.bullet { requires transitive org.bytedeco.javacpp; + exports org.bytedeco.bullet.global; exports org.bytedeco.bullet.presets; exports org.bytedeco.bullet.LinearMath; exports org.bytedeco.bullet.BulletCollision; From efa075bb728530a057426614a11a3cbb824139d5 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 14 Feb 2022 14:14:03 +0800 Subject: [PATCH 08/81] Remove forward declaration of btRigidBody from btDispatcher.h Otherwise, it conflicts with the BulletDynamics' implementation of btRigidBody. --- .../bullet/BulletCollision/btRigidBody.java | 21 ------------------- .../bullet/global/BulletCollision.java | 3 --- .../bullet/presets/BulletCollision.java | 1 + 3 files changed, 1 insertion(+), 24 deletions(-) delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btRigidBody.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btRigidBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btRigidBody.java deleted file mode 100644 index 67b920352a7..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btRigidBody.java +++ /dev/null @@ -1,21 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletCollision; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; - -import static org.bytedeco.bullet.global.BulletCollision.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btRigidBody extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btRigidBody() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btRigidBody(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index 65d7755c4aa..ac1dc7969f0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -133,9 +133,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #ifndef BT_DISPATCHER_H // #define BT_DISPATCHER_H // #include "LinearMath/btScalar.h" -// Targeting ../BulletCollision/btRigidBody.java - - // Targeting ../BulletCollision/btCollisionObjectWrapper.java diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 52d3742b92d..1436af120e4 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -87,6 +87,7 @@ public void map(InfoMap infoMap) { .put(new Info("btDbvtBroadphase::m_rayTestStacks").skip()) .put(new Info("btDbvtProxy").skip()) .put(new Info("DBVT_BP_PROFILE").define(false)) + .put(new Info("btDispatcher.h").linePatterns("class btRigidBody;").skip()) ; } } From 9958160b4d1d7392568632a688b28fa15795c66b Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 14 Feb 2022 15:16:46 +0800 Subject: [PATCH 09/81] Generate bindings for btConvexShape It is part of the btBoxShape hierarchy. --- .../bullet/BulletCollision/btConvexShape.java | 46 +++++++++++++++++-- .../bullet/global/BulletCollision.java | 39 ++++++++++++++-- .../bullet/presets/BulletCollision.java | 1 + 3 files changed, 79 insertions(+), 7 deletions(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java index a26091ab48f..36934a041ec 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java @@ -12,10 +12,48 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btConvexShape extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btConvexShape() { super((Pointer)null); } + +/** The btConvexShape is an abstract shape interface, implemented by all convex shapes such as btBoxShape, btConvexHullShape etc. + * It describes general convex shapes using the localGetSupportingVertex interface, used by collision detectors such as btGjkPairDetector. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexShape extends btCollisionShape { + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btConvexShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + +//////// +// #ifndef __SPU__ + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); +// #endif //#ifndef __SPU__ + + public native @ByVal btVector3 localGetSupportVertexWithoutMarginNonVirtual(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportVertexNonVirtual(@Const @ByRef btVector3 vec); + public native @Cast("btScalar") float getMarginNonVirtual(); + public native void getAabbNonVirtual(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatPointer minProj, @Cast("btScalar*") @ByRef FloatPointer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatBuffer minProj, @Cast("btScalar*") @ByRef FloatBuffer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef float[] minProj, @Cast("btScalar*") @ByRef float[] maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + + //notice that the vectors should be unit length + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void getAabbSlow(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void setMargin(@Cast("btScalar") float margin); + + public native @Cast("btScalar") float getMargin(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index ac1dc7969f0..f40150c9076 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -753,9 +753,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #ifndef BT_COLLISION_WORLD_H // #define BT_COLLISION_WORLD_H -// Targeting ../BulletCollision/btConvexShape.java - - // #include "LinearMath/btVector3.h" // #include "LinearMath/btTransform.h" @@ -949,6 +946,42 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #endif //BT_COLLISION_SHAPE_H +// Parsed from BulletCollision/CollisionShapes/btConvexShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_SHAPE_INTERFACE1 +// #define BT_CONVEX_SHAPE_INTERFACE1 + +// #include "btCollisionShape.h" + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// #include "LinearMath/btAlignedAllocator.h" + +public static final int MAX_PREFERRED_PENETRATION_DIRECTIONS = 10; +// Targeting ../BulletCollision/btConvexShape.java + + + +// #endif //BT_CONVEX_SHAPE_INTERFACE1 + + // Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h /* diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 1436af120e4..7fb41577a7a 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -33,6 +33,7 @@ "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h", "BulletCollision/CollisionShapes/btCollisionShape.h", + "BulletCollision/CollisionShapes/btConvexShape.h", "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h", "BulletCollision/CollisionShapes/btConvexInternalShape.h", "BulletCollision/CollisionShapes/btBoxShape.h", From a077fe6ec01394ba611fe0bcba757116d09b3c28 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 15 Feb 2022 22:29:36 +0800 Subject: [PATCH 10/81] Add bullet's sample Check usability of generated bindings. --- bullet/samples/SimpleBox.java | 80 +++++++++++++++++++++++++++++++++++ bullet/samples/pom.xml | 21 +++++++++ 2 files changed, 101 insertions(+) create mode 100644 bullet/samples/SimpleBox.java create mode 100644 bullet/samples/pom.xml diff --git a/bullet/samples/SimpleBox.java b/bullet/samples/SimpleBox.java new file mode 100644 index 00000000000..f841454b0b2 --- /dev/null +++ b/bullet/samples/SimpleBox.java @@ -0,0 +1,80 @@ +import org.bytedeco.javacpp.*; +import org.bytedeco.bullet.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import org.bytedeco.bullet.LinearMath.*; + +public class SimpleBox { + + private static btDefaultCollisionConfiguration m_collisionConfiguration; + private static btCollisionDispatcher m_dispatcher; + private static btBroadphaseInterface m_broadphase; + private static btConstraintSolver m_solver; + private static btDiscreteDynamicsWorld m_dynamicsWorld; + + public static void main(String[] args) + { + createEmptyDynamicsWorld(); + + btBoxShape groundShape = new btBoxShape(new btVector3(50, 50, 50)); + + btTransform groundTransform = new btTransform(); + groundTransform.setIdentity(); + groundTransform.setOrigin(new btVector3(0, -50, 0)); + + createRigidBody(0, groundTransform, groundShape); + + btBoxShape colShape = new btBoxShape(new btVector3(1, 1, 1)); + float mass = 1.0f; + + colShape.calculateLocalInertia(mass, new btVector3(0, 0, 0)); + + btTransform startTransform = new btTransform(); + startTransform.setIdentity(); + startTransform.setOrigin(new btVector3(0, 3, 0)); + btRigidBody box = createRigidBody(mass, startTransform, colShape); + + for (int i = 0; i < 10; ++ i) + { + m_dynamicsWorld.stepSimulation(0.1f, 10, 0.01f); + btVector3 position = box.getWorldTransform().getOrigin(); + System.out.println(position.y()); + } + } + + private static void createEmptyDynamicsWorld() + { + m_collisionConfiguration = new btDefaultCollisionConfiguration(); + m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); + m_broadphase = new btDbvtBroadphase(); + m_solver = new btSequentialImpulseConstraintSolver(); + m_dynamicsWorld = new btDiscreteDynamicsWorld( + m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration); + m_dynamicsWorld.setGravity(new btVector3(0, -10, 0)); + } + + private static btRigidBody createRigidBody( + float mass, + btTransform startTransform, + btCollisionShape shape) + { + boolean isDynamic = (mass != 0.f); + + btVector3 localInertia = new btVector3(0, 0, 0); + if (isDynamic) + shape.calculateLocalInertia(mass, localInertia); + + btDefaultMotionState motionState = new btDefaultMotionState( + startTransform, btTransform.getIdentity()); + + btRigidBody.btRigidBodyConstructionInfo cInfo = + new btRigidBody.btRigidBodyConstructionInfo( + mass, motionState, shape, localInertia); + + btRigidBody body = new btRigidBody(cInfo); + + body.setUserIndex(-1); + m_dynamicsWorld.addRigidBody(body); + + return body; + } +} diff --git a/bullet/samples/pom.xml b/bullet/samples/pom.xml new file mode 100644 index 00000000000..44f4537db36 --- /dev/null +++ b/bullet/samples/pom.xml @@ -0,0 +1,21 @@ + + 4.0.0 + org.bytedeco.bullet + samples + 1.5.7 + + SimpleBox + 1.7 + 1.7 + + + + org.bytedeco + bullet-platform + 3.21-1.5.7 + + + + . + + From f4f263fa8d3fb705976eaf6671fc203461e9bae7 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 17 Feb 2022 23:44:08 +0800 Subject: [PATCH 11/81] Generate bindings for BulletSoftBody library --- .../ContactDestroyedCallback.java | 26 + .../BulletCollision/ContactEndedCallback.java | 23 + .../ContactProcessedCallback.java | 23 + .../ContactStartedCallback.java | 23 + .../BulletCollision/btCollisionResult.java | 22 + .../BulletCollision/btCollisionWorld.java | 2 +- .../BulletCollision/btPersistentManifold.java | 81 +- .../btPersistentManifoldDoubleData.java | 107 ++ .../btPersistentManifoldFloatData.java | 106 ++ .../BulletCollision/btQuantizedBvh.java | 6 +- .../btTriangleIndexVertexArray.java | 2 +- .../MultiBodyInplaceSolverIslandCallback.java | 23 + ... => btAlignedObjectArray_btRigidBody.java} | 24 +- .../btDiscreteDynamicsWorld.java | 2 +- .../bullet/BulletDynamics/btMultiBody.java | 532 ++++++ .../BulletDynamics/btMultiBodyConstraint.java | 74 + .../btMultiBodyConstraintSolver.java | 23 + .../BulletDynamics/btMultiBodyDoubleData.java | 50 + .../btMultiBodyDynamicsWorld.java | 73 + .../BulletDynamics/btMultiBodyFloatData.java | 49 + .../btMultiBodyJacobianData.java | 44 + .../btMultiBodyJointFeedback.java | 37 + .../btMultiBodyLinkCollider.java | 43 + .../btMultiBodyLinkColliderDoubleData.java | 41 + .../btMultiBodyLinkColliderFloatData.java | 43 + .../btMultiBodyLinkDoubleData.java | 74 + .../btMultiBodyLinkFloatData.java | 72 + .../BulletDynamics/btMultibodyLink.java | 154 ++ ...sistentManifold.java => btSolverInfo.java} | 6 +- ...rmableBodyInplaceSolverIslandCallback.java | 25 + .../MultiBodyInplaceSolverIslandCallback.java | 25 + .../btAlignedObjectArray_btSoftBody.java | 96 + .../btCollisionObjectWrapper.java | 25 + .../btDeformableBackwardEulerObjective.java | 25 + .../btDeformableBodySolver.java | 137 ++ .../btDeformableLagrangianForce.java | 25 + ...btDeformableMultiBodyConstraintSolver.java | 50 + .../btDeformableMultiBodyDynamicsWorld.java | 117 ++ .../btGjkEpaPenetrationDepthSolver.java | 25 + .../bullet/BulletSoftBody/btSoftBody.java | 1673 +++++++++++++++++ .../BulletSoftBody/btSoftBodyHelpers.java | 232 +++ .../BulletSoftBody/btSoftBodyLinkData.java | 25 + ...ftBodyRigidBodyCollisionConfiguration.java | 43 + .../BulletSoftBody/btSoftBodySolver.java | 90 + .../btSoftBodySolverOutput.java | 33 + .../btSoftBodyTriangleData.java | 26 + .../BulletSoftBody/btSoftBodyVertexData.java | 25 + .../BulletSoftBody/btSoftBodyWorldInfo.java | 48 + .../btSoftMultiBodyDynamicsWorld.java | 63 + .../btSoftRigidDynamicsWorld.java | 62 + .../bullet/BulletSoftBody/btSparseSdf_3.java | 85 + .../btVertexBufferDescriptor.java | 25 + .../btVoronoiSimplexSolver.java | 26 + .../bullet/BulletSoftBody/fDrawFlags.java | 60 + .../LinearMath/btAlignedObjectArray_bool.java | 90 + .../btAlignedObjectArray_btMatrix3x3.java | 86 + .../btAlignedObjectArray_btQuaternion.java | 86 + .../btAlignedObjectArray_btVector3.java | 4 - .../btAlignedObjectArray_btVector4.java | 86 + .../LinearMath/btAlignedObjectArray_int.java | 86 + .../LinearMath/btSpatialForceVector.java | 63 + .../LinearMath/btSpatialMotionVector.java | 64 + .../btSpatialTransformationMatrix.java | 47 + .../LinearMath/btSymmetricSpatialDyad.java | 47 + .../bullet/global/BulletCollision.java | 79 +- .../bullet/global/BulletDynamics.java | 278 ++- .../bullet/global/BulletSoftBody.java | 447 +++++ .../bytedeco/bullet/global/LinearMath.java | 56 +- .../bullet/presets/BulletCollision.java | 7 + .../bullet/presets/BulletDynamics.java | 18 +- .../bullet/presets/BulletSoftBody.java | 80 + .../bytedeco/bullet/presets/LinearMath.java | 9 +- bullet/src/main/java9/module-info.java | 1 + 73 files changed, 6445 insertions(+), 40 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactDestroyedCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactEndedCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactProcessedCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactStartedCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionResult.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java rename bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/{btAlignedObjectArray_btRigidBodyPointer.java => btAlignedObjectArray_btRigidBody.java} (78%) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointFeedback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java rename bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/{btPersistentManifold.java => btSolverInfo.java} (81%) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btGjkEpaPenetrationDepthSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVoronoiSimplexSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialForceVector.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialTransformationMatrix.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactDestroyedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactDestroyedCallback.java new file mode 100644 index 00000000000..31b40bc2ff1 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactDestroyedCallback.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// #ifndef SWIG + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class ContactDestroyedCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ContactDestroyedCallback(Pointer p) { super(p); } + protected ContactDestroyedCallback() { allocate(); } + private native void allocate(); + public native @Cast("bool") boolean call(Pointer userPersistentData); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactEndedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactEndedCallback.java new file mode 100644 index 00000000000..78acc7bf2c1 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactEndedCallback.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class ContactEndedCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ContactEndedCallback(Pointer p) { super(p); } + protected ContactEndedCallback() { allocate(); } + private native void allocate(); + public native void call(@ByPtrRef btPersistentManifold manifold); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactProcessedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactProcessedCallback.java new file mode 100644 index 00000000000..b97fb675d73 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactProcessedCallback.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class ContactProcessedCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ContactProcessedCallback(Pointer p) { super(p); } + protected ContactProcessedCallback() { allocate(); } + private native void allocate(); + public native @Cast("bool") boolean call(@ByRef btManifoldPoint cp, Pointer body0, Pointer body1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactStartedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactStartedCallback.java new file mode 100644 index 00000000000..da40d99f434 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactStartedCallback.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class ContactStartedCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ContactStartedCallback(Pointer p) { super(p); } + protected ContactStartedCallback() { allocate(); } + private native void allocate(); + public native void call(@ByPtrRef btPersistentManifold manifold); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionResult.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionResult.java new file mode 100644 index 00000000000..8fe2954082f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionResult.java @@ -0,0 +1,22 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionResult extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionResult() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionResult(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java index 8fe49f787fa..3b88736f9c0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java @@ -271,7 +271,7 @@ public static native void objectQuerySingleInternal(@Const btConvexShape castSha public native void refreshBroadphaseProxy(btCollisionObject collisionObject); - public native @Cast("btCollisionObjectArray*") @ByRef btAlignedObjectArray_btVector3 getCollisionObjectArray(); + public native @Cast("btCollisionObjectArray*") @ByRef btAlignedObjectArray_bool getCollisionObjectArray(); public native void removeCollisionObject(btCollisionObject collisionObject); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java index a2e1bba8fc9..7bf939494a9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java @@ -13,10 +13,83 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btPersistentManifold extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btPersistentManifold() { super((Pointer)null); } +/**btPersistentManifold is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase. + * Those contact points are created by the collision narrow phase. + * The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time. + * updates/refreshes old contact points, and throw them away if necessary (distance becomes too large) + * reduces the cache to 4 points, when more then 4 points are added, using following rules: + * the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points + * note that some pairs of objects might have more then one contact manifold. */ + +//ATTRIBUTE_ALIGNED128( class) btPersistentManifold : public btTypedObject +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPersistentManifold extends btTypedObject { + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btPersistentManifold(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPersistentManifold(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btPersistentManifold position(long position) { + return (btPersistentManifold)super.position(position); + } + @Override public btPersistentManifold getPointer(long i) { + return new btPersistentManifold((Pointer)this).offsetAddress(i); + } + + + public native int m_companionIdA(); public native btPersistentManifold m_companionIdA(int setter); + public native int m_companionIdB(); public native btPersistentManifold m_companionIdB(int setter); + + public native int m_index1a(); public native btPersistentManifold m_index1a(int setter); + + public btPersistentManifold() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btPersistentManifold(@Const btCollisionObject body0, @Const btCollisionObject body1, int arg2, @Cast("btScalar") float contactBreakingThreshold, @Cast("btScalar") float contactProcessingThreshold) { super((Pointer)null); allocate(body0, body1, arg2, contactBreakingThreshold, contactProcessingThreshold); } + private native void allocate(@Const btCollisionObject body0, @Const btCollisionObject body1, int arg2, @Cast("btScalar") float contactBreakingThreshold, @Cast("btScalar") float contactProcessingThreshold); + + public native @Const btCollisionObject getBody0(); + public native @Const btCollisionObject getBody1(); + + public native void setBodies(@Const btCollisionObject body0, @Const btCollisionObject body1); + + public native void clearUserCache(@ByRef btManifoldPoint pt); + +// #ifdef DEBUG_PERSISTENCY +// #endif // + + public native int getNumContacts(); + /** the setNumContacts API is usually not used, except when you gather/fill all contacts manually */ + public native void setNumContacts(int cachedPoints); + + public native @ByRef btManifoldPoint getContactPoint(int index); + + /**\todo: get this margin from the current physics / collision environment */ + public native @Cast("btScalar") float getContactBreakingThreshold(); + + public native @Cast("btScalar") float getContactProcessingThreshold(); + + public native void setContactBreakingThreshold(@Cast("btScalar") float contactBreakingThreshold); + + public native void setContactProcessingThreshold(@Cast("btScalar") float contactProcessingThreshold); + + public native int getCacheEntry(@Const @ByRef btManifoldPoint newPoint); + + public native int addManifoldPoint(@Const @ByRef btManifoldPoint newPoint, @Cast("bool") boolean isPredictive/*=false*/); + public native int addManifoldPoint(@Const @ByRef btManifoldPoint newPoint); + + public native void removeContactPoint(int index); + public native void replaceContactPoint(@Const @ByRef btManifoldPoint newPoint, int insertIndex); + + public native @Cast("bool") boolean validContactDistance(@Const @ByRef btManifoldPoint pt); + /** calculated new worldspace coordinates and depth, and reject points that exceed the collision margin */ + public native void refreshContactPoints(@Const @ByRef btTransform trA, @Const @ByRef btTransform trB); + + public native void clearManifold(); + + public native int calculateSerializeBufferSize(); + public native @Cast("const char*") BytePointer serialize(@Const btPersistentManifold manifold, Pointer dataBuffer, btSerializer serializer); + public native void deSerialize(@Const btPersistentManifoldDoubleData manifoldDataPtr); + public native void deSerialize(@Const btPersistentManifoldFloatData manifoldDataPtr); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldDoubleData.java new file mode 100644 index 00000000000..ed2afa5d400 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldDoubleData.java @@ -0,0 +1,107 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// clang-format off + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPersistentManifoldDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPersistentManifoldDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPersistentManifoldDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPersistentManifoldDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPersistentManifoldDoubleData position(long position) { + return (btPersistentManifoldDoubleData)super.position(position); + } + @Override public btPersistentManifoldDoubleData getPointer(long i) { + return new btPersistentManifoldDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3DoubleData m_pointCacheLocalPointA(int i); public native btPersistentManifoldDoubleData m_pointCacheLocalPointA(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_pointCacheLocalPointA(); + public native @ByRef btVector3DoubleData m_pointCacheLocalPointB(int i); public native btPersistentManifoldDoubleData m_pointCacheLocalPointB(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_pointCacheLocalPointB(); + public native @ByRef btVector3DoubleData m_pointCachePositionWorldOnA(int i); public native btPersistentManifoldDoubleData m_pointCachePositionWorldOnA(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_pointCachePositionWorldOnA(); + public native @ByRef btVector3DoubleData m_pointCachePositionWorldOnB(int i); public native btPersistentManifoldDoubleData m_pointCachePositionWorldOnB(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_pointCachePositionWorldOnB(); + public native @ByRef btVector3DoubleData m_pointCacheNormalWorldOnB(int i); public native btPersistentManifoldDoubleData m_pointCacheNormalWorldOnB(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_pointCacheNormalWorldOnB(); + public native @ByRef btVector3DoubleData m_pointCacheLateralFrictionDir1(int i); public native btPersistentManifoldDoubleData m_pointCacheLateralFrictionDir1(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_pointCacheLateralFrictionDir1(); + public native @ByRef btVector3DoubleData m_pointCacheLateralFrictionDir2(int i); public native btPersistentManifoldDoubleData m_pointCacheLateralFrictionDir2(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_pointCacheLateralFrictionDir2(); + public native double m_pointCacheDistance(int i); public native btPersistentManifoldDoubleData m_pointCacheDistance(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheDistance(); + public native double m_pointCacheAppliedImpulse(int i); public native btPersistentManifoldDoubleData m_pointCacheAppliedImpulse(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheAppliedImpulse(); + public native double m_pointCachePrevRHS(int i); public native btPersistentManifoldDoubleData m_pointCachePrevRHS(int i, double setter); + @MemberGetter public native DoublePointer m_pointCachePrevRHS(); + public native double m_pointCacheCombinedFriction(int i); public native btPersistentManifoldDoubleData m_pointCacheCombinedFriction(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheCombinedFriction(); + public native double m_pointCacheCombinedRollingFriction(int i); public native btPersistentManifoldDoubleData m_pointCacheCombinedRollingFriction(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheCombinedRollingFriction(); + public native double m_pointCacheCombinedSpinningFriction(int i); public native btPersistentManifoldDoubleData m_pointCacheCombinedSpinningFriction(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheCombinedSpinningFriction(); + public native double m_pointCacheCombinedRestitution(int i); public native btPersistentManifoldDoubleData m_pointCacheCombinedRestitution(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheCombinedRestitution(); + public native int m_pointCachePartId0(int i); public native btPersistentManifoldDoubleData m_pointCachePartId0(int i, int setter); + @MemberGetter public native IntPointer m_pointCachePartId0(); + public native int m_pointCachePartId1(int i); public native btPersistentManifoldDoubleData m_pointCachePartId1(int i, int setter); + @MemberGetter public native IntPointer m_pointCachePartId1(); + public native int m_pointCacheIndex0(int i); public native btPersistentManifoldDoubleData m_pointCacheIndex0(int i, int setter); + @MemberGetter public native IntPointer m_pointCacheIndex0(); + public native int m_pointCacheIndex1(int i); public native btPersistentManifoldDoubleData m_pointCacheIndex1(int i, int setter); + @MemberGetter public native IntPointer m_pointCacheIndex1(); + public native int m_pointCacheContactPointFlags(int i); public native btPersistentManifoldDoubleData m_pointCacheContactPointFlags(int i, int setter); + @MemberGetter public native IntPointer m_pointCacheContactPointFlags(); + public native double m_pointCacheAppliedImpulseLateral1(int i); public native btPersistentManifoldDoubleData m_pointCacheAppliedImpulseLateral1(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheAppliedImpulseLateral1(); + public native double m_pointCacheAppliedImpulseLateral2(int i); public native btPersistentManifoldDoubleData m_pointCacheAppliedImpulseLateral2(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheAppliedImpulseLateral2(); + public native double m_pointCacheContactMotion1(int i); public native btPersistentManifoldDoubleData m_pointCacheContactMotion1(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheContactMotion1(); + public native double m_pointCacheContactMotion2(int i); public native btPersistentManifoldDoubleData m_pointCacheContactMotion2(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheContactMotion2(); + public native double m_pointCacheContactCFM(int i); public native btPersistentManifoldDoubleData m_pointCacheContactCFM(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheContactCFM(); + public native double m_pointCacheCombinedContactStiffness1(int i); public native btPersistentManifoldDoubleData m_pointCacheCombinedContactStiffness1(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheCombinedContactStiffness1(); + public native double m_pointCacheContactERP(int i); public native btPersistentManifoldDoubleData m_pointCacheContactERP(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheContactERP(); + public native double m_pointCacheCombinedContactDamping1(int i); public native btPersistentManifoldDoubleData m_pointCacheCombinedContactDamping1(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheCombinedContactDamping1(); + public native double m_pointCacheFrictionCFM(int i); public native btPersistentManifoldDoubleData m_pointCacheFrictionCFM(int i, double setter); + @MemberGetter public native DoublePointer m_pointCacheFrictionCFM(); + public native int m_pointCacheLifeTime(int i); public native btPersistentManifoldDoubleData m_pointCacheLifeTime(int i, int setter); + @MemberGetter public native IntPointer m_pointCacheLifeTime(); + + public native int m_numCachedPoints(); public native btPersistentManifoldDoubleData m_numCachedPoints(int setter); + public native int m_companionIdA(); public native btPersistentManifoldDoubleData m_companionIdA(int setter); + public native int m_companionIdB(); public native btPersistentManifoldDoubleData m_companionIdB(int setter); + public native int m_index1a(); public native btPersistentManifoldDoubleData m_index1a(int setter); + + public native int m_objectType(); public native btPersistentManifoldDoubleData m_objectType(int setter); + public native double m_contactBreakingThreshold(); public native btPersistentManifoldDoubleData m_contactBreakingThreshold(double setter); + public native double m_contactProcessingThreshold(); public native btPersistentManifoldDoubleData m_contactProcessingThreshold(double setter); + public native int m_padding(); public native btPersistentManifoldDoubleData m_padding(int setter); + + public native btCollisionObjectDoubleData m_body0(); public native btPersistentManifoldDoubleData m_body0(btCollisionObjectDoubleData setter); + public native btCollisionObjectDoubleData m_body1(); public native btPersistentManifoldDoubleData m_body1(btCollisionObjectDoubleData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldFloatData.java new file mode 100644 index 00000000000..b2e3bc7333b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldFloatData.java @@ -0,0 +1,106 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPersistentManifoldFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPersistentManifoldFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPersistentManifoldFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPersistentManifoldFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPersistentManifoldFloatData position(long position) { + return (btPersistentManifoldFloatData)super.position(position); + } + @Override public btPersistentManifoldFloatData getPointer(long i) { + return new btPersistentManifoldFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_pointCacheLocalPointA(int i); public native btPersistentManifoldFloatData m_pointCacheLocalPointA(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_pointCacheLocalPointA(); + public native @ByRef btVector3FloatData m_pointCacheLocalPointB(int i); public native btPersistentManifoldFloatData m_pointCacheLocalPointB(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_pointCacheLocalPointB(); + public native @ByRef btVector3FloatData m_pointCachePositionWorldOnA(int i); public native btPersistentManifoldFloatData m_pointCachePositionWorldOnA(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_pointCachePositionWorldOnA(); + public native @ByRef btVector3FloatData m_pointCachePositionWorldOnB(int i); public native btPersistentManifoldFloatData m_pointCachePositionWorldOnB(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_pointCachePositionWorldOnB(); + public native @ByRef btVector3FloatData m_pointCacheNormalWorldOnB(int i); public native btPersistentManifoldFloatData m_pointCacheNormalWorldOnB(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_pointCacheNormalWorldOnB(); + public native @ByRef btVector3FloatData m_pointCacheLateralFrictionDir1(int i); public native btPersistentManifoldFloatData m_pointCacheLateralFrictionDir1(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_pointCacheLateralFrictionDir1(); + public native @ByRef btVector3FloatData m_pointCacheLateralFrictionDir2(int i); public native btPersistentManifoldFloatData m_pointCacheLateralFrictionDir2(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_pointCacheLateralFrictionDir2(); + public native float m_pointCacheDistance(int i); public native btPersistentManifoldFloatData m_pointCacheDistance(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheDistance(); + public native float m_pointCacheAppliedImpulse(int i); public native btPersistentManifoldFloatData m_pointCacheAppliedImpulse(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheAppliedImpulse(); + public native float m_pointCachePrevRHS(int i); public native btPersistentManifoldFloatData m_pointCachePrevRHS(int i, float setter); + @MemberGetter public native FloatPointer m_pointCachePrevRHS(); + public native float m_pointCacheCombinedFriction(int i); public native btPersistentManifoldFloatData m_pointCacheCombinedFriction(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheCombinedFriction(); + public native float m_pointCacheCombinedRollingFriction(int i); public native btPersistentManifoldFloatData m_pointCacheCombinedRollingFriction(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheCombinedRollingFriction(); + public native float m_pointCacheCombinedSpinningFriction(int i); public native btPersistentManifoldFloatData m_pointCacheCombinedSpinningFriction(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheCombinedSpinningFriction(); + public native float m_pointCacheCombinedRestitution(int i); public native btPersistentManifoldFloatData m_pointCacheCombinedRestitution(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheCombinedRestitution(); + public native int m_pointCachePartId0(int i); public native btPersistentManifoldFloatData m_pointCachePartId0(int i, int setter); + @MemberGetter public native IntPointer m_pointCachePartId0(); + public native int m_pointCachePartId1(int i); public native btPersistentManifoldFloatData m_pointCachePartId1(int i, int setter); + @MemberGetter public native IntPointer m_pointCachePartId1(); + public native int m_pointCacheIndex0(int i); public native btPersistentManifoldFloatData m_pointCacheIndex0(int i, int setter); + @MemberGetter public native IntPointer m_pointCacheIndex0(); + public native int m_pointCacheIndex1(int i); public native btPersistentManifoldFloatData m_pointCacheIndex1(int i, int setter); + @MemberGetter public native IntPointer m_pointCacheIndex1(); + public native int m_pointCacheContactPointFlags(int i); public native btPersistentManifoldFloatData m_pointCacheContactPointFlags(int i, int setter); + @MemberGetter public native IntPointer m_pointCacheContactPointFlags(); + public native float m_pointCacheAppliedImpulseLateral1(int i); public native btPersistentManifoldFloatData m_pointCacheAppliedImpulseLateral1(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheAppliedImpulseLateral1(); + public native float m_pointCacheAppliedImpulseLateral2(int i); public native btPersistentManifoldFloatData m_pointCacheAppliedImpulseLateral2(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheAppliedImpulseLateral2(); + public native float m_pointCacheContactMotion1(int i); public native btPersistentManifoldFloatData m_pointCacheContactMotion1(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheContactMotion1(); + public native float m_pointCacheContactMotion2(int i); public native btPersistentManifoldFloatData m_pointCacheContactMotion2(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheContactMotion2(); + public native float m_pointCacheContactCFM(int i); public native btPersistentManifoldFloatData m_pointCacheContactCFM(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheContactCFM(); + public native float m_pointCacheCombinedContactStiffness1(int i); public native btPersistentManifoldFloatData m_pointCacheCombinedContactStiffness1(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheCombinedContactStiffness1(); + public native float m_pointCacheContactERP(int i); public native btPersistentManifoldFloatData m_pointCacheContactERP(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheContactERP(); + public native float m_pointCacheCombinedContactDamping1(int i); public native btPersistentManifoldFloatData m_pointCacheCombinedContactDamping1(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheCombinedContactDamping1(); + public native float m_pointCacheFrictionCFM(int i); public native btPersistentManifoldFloatData m_pointCacheFrictionCFM(int i, float setter); + @MemberGetter public native FloatPointer m_pointCacheFrictionCFM(); + public native int m_pointCacheLifeTime(int i); public native btPersistentManifoldFloatData m_pointCacheLifeTime(int i, int setter); + @MemberGetter public native IntPointer m_pointCacheLifeTime(); + + public native int m_numCachedPoints(); public native btPersistentManifoldFloatData m_numCachedPoints(int setter); + public native int m_companionIdA(); public native btPersistentManifoldFloatData m_companionIdA(int setter); + public native int m_companionIdB(); public native btPersistentManifoldFloatData m_companionIdB(int setter); + public native int m_index1a(); public native btPersistentManifoldFloatData m_index1a(int setter); + + public native int m_objectType(); public native btPersistentManifoldFloatData m_objectType(int setter); + public native float m_contactBreakingThreshold(); public native btPersistentManifoldFloatData m_contactBreakingThreshold(float setter); + public native float m_contactProcessingThreshold(); public native btPersistentManifoldFloatData m_contactProcessingThreshold(float setter); + public native int m_padding(); public native btPersistentManifoldFloatData m_padding(int setter); + + public native btCollisionObjectFloatData m_body0(); public native btPersistentManifoldFloatData m_body0(btCollisionObjectFloatData setter); + public native btCollisionObjectFloatData m_body1(); public native btPersistentManifoldFloatData m_body1(btCollisionObjectFloatData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java index 0296199aa56..9436000bf80 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java @@ -43,7 +43,7 @@ public class btQuantizedBvh extends Pointer { ///***************************************** expert/internal use only ************************* public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("btScalar") float quantizationMargin/*=btScalar(1.0)*/); public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); - public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btVector3 getLeafNodeArray(); + public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_bool getLeafNodeArray(); /**buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized */ public native void buildInternal(); ///***************************************** expert/internal use only ************************* @@ -67,9 +67,9 @@ public class btQuantizedBvh extends Pointer { /**setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees. */ public native void setTraversalMode(@Cast("btQuantizedBvh::btTraversalMode") int traversalMode); - public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btVector3 getQuantizedNodeArray(); + public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_bool getQuantizedNodeArray(); - public native @Cast("BvhSubtreeInfoArray*") @ByRef btAlignedObjectArray_btVector3 getSubtreeInfoArray(); + public native @Cast("BvhSubtreeInfoArray*") @ByRef btAlignedObjectArray_bool getSubtreeInfoArray(); //////////////////////////////////////////////////////////////////// diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java index 5df90e4441c..bcb403b31aa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java @@ -73,7 +73,7 @@ public class btTriangleIndexVertexArray extends btStridingMeshInterface { * each subpart has a continuous array of vertices and indices */ public native int getNumSubParts(); - public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btVector3 getIndexedMeshArray(); + public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_bool getIndexedMeshArray(); public native void preallocateVertices(int numverts); public native void preallocateIndices(int numindices); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java new file mode 100644 index 00000000000..d64afe2626a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class MultiBodyInplaceSolverIslandCallback extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public MultiBodyInplaceSolverIslandCallback() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public MultiBodyInplaceSolverIslandCallback(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java similarity index 78% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java index 07f62908439..d708d3440d9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java @@ -19,27 +19,27 @@ /**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btAlignedObjectArray_btRigidBodyPointer extends Pointer { +public class btAlignedObjectArray_btRigidBody extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btRigidBodyPointer(Pointer p) { super(p); } + public btAlignedObjectArray_btRigidBody(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btRigidBodyPointer(long size) { super((Pointer)null); allocateArray(size); } + public btAlignedObjectArray_btRigidBody(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btRigidBodyPointer position(long position) { - return (btAlignedObjectArray_btRigidBodyPointer)super.position(position); + @Override public btAlignedObjectArray_btRigidBody position(long position) { + return (btAlignedObjectArray_btRigidBody)super.position(position); } - @Override public btAlignedObjectArray_btRigidBodyPointer getPointer(long i) { - return new btAlignedObjectArray_btRigidBodyPointer((Pointer)this).offsetAddress(i); + @Override public btAlignedObjectArray_btRigidBody getPointer(long i) { + return new btAlignedObjectArray_btRigidBody((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btRigidBodyPointer put(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer other); - public btAlignedObjectArray_btRigidBodyPointer() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btAlignedObjectArray_btRigidBody put(@Const @ByRef btAlignedObjectArray_btRigidBody other); + public btAlignedObjectArray_btRigidBody() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btRigidBodyPointer(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); + public btAlignedObjectArray_btRigidBody(@Const @ByRef btAlignedObjectArray_btRigidBody otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btRigidBody otherArray); /** return the number of elements in the array */ public native int size(); @@ -90,5 +90,5 @@ public class btAlignedObjectArray_btRigidBodyPointer extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btRigidBody otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java index d3541154207..ee87f215079 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java @@ -117,5 +117,5 @@ public class btDiscreteDynamicsWorld extends btDynamicsWorld { public native void setLatencyMotionStateInterpolation(@Cast("bool") boolean latencyInterpolation); public native @Cast("bool") boolean getLatencyMotionStateInterpolation(); - public native @ByRef btAlignedObjectArray_btRigidBodyPointer getNonStaticRigidBodies(); + public native @ByRef btAlignedObjectArray_btRigidBody getNonStaticRigidBodies(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java new file mode 100644 index 00000000000..10439a00d83 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java @@ -0,0 +1,532 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBody extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBody(Pointer p) { super(p); } + + + // + // initialization + // + + public btMultiBody(int n_links, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + @Cast("bool") boolean fixedBase, + @Cast("bool") boolean canSleep, @Cast("bool") boolean deprecatedMultiDof/*=true*/) { super((Pointer)null); allocate(n_links, mass, inertia, fixedBase, canSleep, deprecatedMultiDof); } + private native void allocate(int n_links, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + @Cast("bool") boolean fixedBase, + @Cast("bool") boolean canSleep, @Cast("bool") boolean deprecatedMultiDof/*=true*/); + public btMultiBody(int n_links, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + @Cast("bool") boolean fixedBase, + @Cast("bool") boolean canSleep) { super((Pointer)null); allocate(n_links, mass, inertia, fixedBase, canSleep); } + private native void allocate(int n_links, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + @Cast("bool") boolean fixedBase, + @Cast("bool") boolean canSleep); + + //note: fixed link collision with parent is always disabled + public native void setupFixed(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parent, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 parentComToThisPivotOffset, + @Const @ByRef btVector3 thisPivotToThisComOffset, @Cast("bool") boolean deprecatedDisableParentCollision/*=true*/); + public native void setupFixed(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parent, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 parentComToThisPivotOffset, + @Const @ByRef btVector3 thisPivotToThisComOffset); + + public native void setupPrismatic(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parent, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 jointAxis, + @Const @ByRef btVector3 parentComToThisPivotOffset, + @Const @ByRef btVector3 thisPivotToThisComOffset, + @Cast("bool") boolean disableParentCollision); + + public native void setupRevolute(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parentIndex, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 jointAxis, + @Const @ByRef btVector3 parentComToThisPivotOffset, + @Const @ByRef btVector3 thisPivotToThisComOffset, + @Cast("bool") boolean disableParentCollision/*=false*/); + public native void setupRevolute(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parentIndex, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 jointAxis, + @Const @ByRef btVector3 parentComToThisPivotOffset, + @Const @ByRef btVector3 thisPivotToThisComOffset); + + public native void setupSpherical(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parent, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 parentComToThisPivotOffset, + @Const @ByRef btVector3 thisPivotToThisComOffset, + @Cast("bool") boolean disableParentCollision/*=false*/); + public native void setupSpherical(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parent, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 parentComToThisPivotOffset, + @Const @ByRef btVector3 thisPivotToThisComOffset); + + public native void setupPlanar(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parent, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 rotationAxis, + @Const @ByRef btVector3 parentComToThisComOffset, + @Cast("bool") boolean disableParentCollision/*=false*/); + public native void setupPlanar(int i, + @Cast("btScalar") float mass, + @Const @ByRef btVector3 inertia, + int parent, + @Const @ByRef btQuaternion rotParentToThis, + @Const @ByRef btVector3 rotationAxis, + @Const @ByRef btVector3 parentComToThisComOffset); + + public native @ByRef btMultibodyLink getLink(int index); + + public native void setBaseCollider(btMultiBodyLinkCollider collider); + public native btMultiBodyLinkCollider getBaseCollider(); + + public native btMultiBodyLinkCollider getLinkCollider(int index); + + // + // get parent + // input: link num from 0 to num_links-1 + // output: link num from 0 to num_links-1, OR -1 to mean the base. + // + public native int getParent(int link_num); + + // + // get number of m_links, masses, moments of inertia + // + + public native int getNumLinks(); + public native int getNumDofs(); + public native int getNumPosVars(); + public native @Cast("btScalar") float getBaseMass(); + public native @Const @ByRef btVector3 getBaseInertia(); + public native @Cast("btScalar") float getLinkMass(int i); + public native @Const @ByRef btVector3 getLinkInertia(int i); + + // + // change mass (incomplete: can only change base mass and inertia at present) + // + + public native void setBaseMass(@Cast("btScalar") float mass); + public native void setBaseInertia(@Const @ByRef btVector3 inertia); + + // + // get/set pos/vel/rot/omega for the base link + // + + public native @Const @ByRef btVector3 getBasePos(); // in world frame + public native @Const @ByVal btVector3 getBaseVel(); // in world frame + public native @Const @ByRef btQuaternion getWorldToBaseRot(); + + public native @Const @ByRef btVector3 getInterpolateBasePos(); // in world frame + public native @Const @ByRef btQuaternion getInterpolateWorldToBaseRot(); + + // rotates world vectors into base frame + public native @ByVal btVector3 getBaseOmega(); // in world frame + + public native void setBasePos(@Const @ByRef btVector3 pos); + + public native void setInterpolateBasePos(@Const @ByRef btVector3 pos); + + public native void setBaseWorldTransform(@Const @ByRef btTransform tr); + + public native @ByVal btTransform getBaseWorldTransform(); + + public native void setInterpolateBaseWorldTransform(@Const @ByRef btTransform tr); + + public native @ByVal btTransform getInterpolateBaseWorldTransform(); + + public native void setBaseVel(@Const @ByRef btVector3 vel); + + public native void setWorldToBaseRot(@Const @ByRef btQuaternion rot); + + public native void setInterpolateWorldToBaseRot(@Const @ByRef btQuaternion rot); + + public native void setBaseOmega(@Const @ByRef btVector3 omega); + + public native void saveKinematicState(@Cast("btScalar") float timeStep); + + // + // get/set pos/vel for child m_links (i = 0 to num_links-1) + // + + public native @Cast("btScalar") float getJointPos(int i); + public native @Cast("btScalar") float getJointVel(int i); + + public native @Cast("btScalar*") FloatPointer getJointVelMultiDof(int i); + public native @Cast("btScalar*") FloatPointer getJointPosMultiDof(int i); + + public native void setJointPos(int i, @Cast("btScalar") float q); + public native void setJointVel(int i, @Cast("btScalar") float qdot); + public native void setJointPosMultiDof(int i, @Const DoublePointer q); + public native void setJointPosMultiDof(int i, @Const DoubleBuffer q); + public native void setJointPosMultiDof(int i, @Const double[] q); + public native void setJointVelMultiDof(int i, @Const DoublePointer qdot); + public native void setJointVelMultiDof(int i, @Const DoubleBuffer qdot); + public native void setJointVelMultiDof(int i, @Const double[] qdot); + public native void setJointPosMultiDof(int i, @Const FloatPointer q); + public native void setJointPosMultiDof(int i, @Const FloatBuffer q); + public native void setJointPosMultiDof(int i, @Const float[] q); + public native void setJointVelMultiDof(int i, @Const FloatPointer qdot); + public native void setJointVelMultiDof(int i, @Const FloatBuffer qdot); + public native void setJointVelMultiDof(int i, @Const float[] qdot); + + // + // direct access to velocities as a vector of 6 + num_links elements. + // (omega first, then v, then joint velocities.) + // + public native @Cast("const btScalar*") FloatPointer getVelocityVector(); + + public native @Cast("const btScalar*") FloatPointer getDeltaVelocityVector(); + + public native @Cast("const btScalar*") FloatPointer getSplitVelocityVector(); + /* btScalar * getVelocityVector() + { + return &real_buf[0]; + } + */ + + // + // get the frames of reference (positions and orientations) of the child m_links + // (i = 0 to num_links-1) + // + + public native @Const @ByRef btVector3 getRVector(int i); // vector from COM(parent(i)) to COM(i), in frame i's coords + public native @Const @ByRef btQuaternion getParentToLocalRot(int i); // rotates vectors in frame parent(i) to vectors in frame i. + public native @Const @ByRef btVector3 getInterpolateRVector(int i); // vector from COM(parent(i)) to COM(i), in frame i's coords + public native @Const @ByRef btQuaternion getInterpolateParentToLocalRot(int i); // rotates vectors in frame parent(i) to vectors in frame i. + + // + // transform vectors in local frame of link i to world frame (or vice versa) + // + public native @ByVal btVector3 localPosToWorld(int i, @Const @ByRef btVector3 local_pos); + public native @ByVal btVector3 localDirToWorld(int i, @Const @ByRef btVector3 local_dir); + public native @ByVal btVector3 worldPosToLocal(int i, @Const @ByRef btVector3 world_pos); + public native @ByVal btVector3 worldDirToLocal(int i, @Const @ByRef btVector3 world_dir); + + // + // transform a frame in local coordinate to a frame in world coordinate + // + public native @ByVal btMatrix3x3 localFrameToWorld(int i, @Const @ByRef btMatrix3x3 local_frame); + + + // + // set external forces and torques. Note all external forces/torques are given in the WORLD frame. + // + + public native void clearForcesAndTorques(); + public native void clearConstraintForces(); + + public native void clearVelocities(); + + public native void addBaseForce(@Const @ByRef btVector3 f); + public native void addBaseTorque(@Const @ByRef btVector3 t); + public native void addLinkForce(int i, @Const @ByRef btVector3 f); + public native void addLinkTorque(int i, @Const @ByRef btVector3 t); + + public native void addBaseConstraintForce(@Const @ByRef btVector3 f); + public native void addBaseConstraintTorque(@Const @ByRef btVector3 t); + public native void addLinkConstraintForce(int i, @Const @ByRef btVector3 f); + public native void addLinkConstraintTorque(int i, @Const @ByRef btVector3 t); + + public native void addJointTorque(int i, @Cast("btScalar") float Q); + public native void addJointTorqueMultiDof(int i, int dof, @Cast("btScalar") float Q); + public native void addJointTorqueMultiDof(int i, @Cast("const btScalar*") FloatPointer Q); + public native void addJointTorqueMultiDof(int i, @Cast("const btScalar*") FloatBuffer Q); + public native void addJointTorqueMultiDof(int i, @Cast("const btScalar*") float[] Q); + + public native @Const @ByRef btVector3 getBaseForce(); + public native @Const @ByRef btVector3 getBaseTorque(); + public native @Const @ByRef btVector3 getLinkForce(int i); + public native @Const @ByRef btVector3 getLinkTorque(int i); + public native @Cast("btScalar") float getJointTorque(int i); + public native @Cast("btScalar*") FloatPointer getJointTorqueMultiDof(int i); + + // + // dynamics routines. + // + + // timestep the velocities (given the external forces/torques set using addBaseForce etc). + // also sets up caches for calcAccelerationDeltas. + // + // Note: the caller must provide three vectors which are used as + // temporary scratch space. The idea here is to reduce dynamic + // memory allocation: the same scratch vectors can be re-used + // again and again for different Multibodies, instead of each + // btMultiBody allocating (and then deallocating) their own + // individual scratch buffers. This gives a considerable speed + // improvement, at least on Windows (where dynamic memory + // allocation appears to be fairly slow). + // + + public native void computeAccelerationsArticulatedBodyAlgorithmMultiDof(@Cast("btScalar") float dt, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v, + @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m, + @Cast("bool") boolean isConstraintPass, + @Cast("bool") boolean jointFeedbackInWorldSpace, + @Cast("bool") boolean jointFeedbackInJointFrame + ); + + /**stepVelocitiesMultiDof is deprecated, use computeAccelerationsArticulatedBodyAlgorithmMultiDof instead */ + //void stepVelocitiesMultiDof(btScalar dt, + // btAlignedObjectArray & scratch_r, + // btAlignedObjectArray & scratch_v, + // btAlignedObjectArray & scratch_m, + // bool isConstraintPass = false) + //{ + // computeAccelerationsArticulatedBodyAlgorithmMultiDof(dt, scratch_r, scratch_v, scratch_m, isConstraintPass, false, false); + //} + + // calcAccelerationDeltasMultiDof + // input: force vector (in same format as jacobian, i.e.: + // 3 torque values, 3 force values, num_links joint torque values) + // output: 3 omegadot values, 3 vdot values, num_links q_double_dot values + // (existing contents of output array are replaced) + // calcAccelerationDeltasMultiDof must have been called first. + public native void calcAccelerationDeltasMultiDof(@Cast("const btScalar*") FloatPointer force, @Cast("btScalar*") FloatPointer output, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v); + public native void calcAccelerationDeltasMultiDof(@Cast("const btScalar*") FloatBuffer force, @Cast("btScalar*") FloatBuffer output, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v); + public native void calcAccelerationDeltasMultiDof(@Cast("const btScalar*") float[] force, @Cast("btScalar*") float[] output, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v); + + public native void applyDeltaVeeMultiDof2(@Cast("const btScalar*") FloatPointer delta_vee, @Cast("btScalar") float multiplier); + public native void applyDeltaVeeMultiDof2(@Cast("const btScalar*") FloatBuffer delta_vee, @Cast("btScalar") float multiplier); + public native void applyDeltaVeeMultiDof2(@Cast("const btScalar*") float[] delta_vee, @Cast("btScalar") float multiplier); + public native void applyDeltaSplitVeeMultiDof(@Cast("const btScalar*") FloatPointer delta_vee, @Cast("btScalar") float multiplier); + public native void applyDeltaSplitVeeMultiDof(@Cast("const btScalar*") FloatBuffer delta_vee, @Cast("btScalar") float multiplier); + public native void applyDeltaSplitVeeMultiDof(@Cast("const btScalar*") float[] delta_vee, @Cast("btScalar") float multiplier); + public native void addSplitV(); + public native void substractSplitV(); + public native void processDeltaVeeMultiDof2(); + + public native void applyDeltaVeeMultiDof(@Cast("const btScalar*") FloatPointer delta_vee, @Cast("btScalar") float multiplier); + public native void applyDeltaVeeMultiDof(@Cast("const btScalar*") FloatBuffer delta_vee, @Cast("btScalar") float multiplier); + public native void applyDeltaVeeMultiDof(@Cast("const btScalar*") float[] delta_vee, @Cast("btScalar") float multiplier); + + // timestep the positions (given current velocities). + public native void stepPositionsMultiDof(@Cast("btScalar") float dt, @Cast("btScalar*") FloatPointer pq/*=0*/, @Cast("btScalar*") FloatPointer pqd/*=0*/); + public native void stepPositionsMultiDof(@Cast("btScalar") float dt); + public native void stepPositionsMultiDof(@Cast("btScalar") float dt, @Cast("btScalar*") FloatBuffer pq/*=0*/, @Cast("btScalar*") FloatBuffer pqd/*=0*/); + public native void stepPositionsMultiDof(@Cast("btScalar") float dt, @Cast("btScalar*") float[] pq/*=0*/, @Cast("btScalar*") float[] pqd/*=0*/); + + // predict the positions + public native void predictPositionsMultiDof(@Cast("btScalar") float dt); + + // + // contacts + // + + // This routine fills out a contact constraint jacobian for this body. + // the 'normal' supplied must be -n for body1 or +n for body2 of the contact. + // 'normal' & 'contact_point' are both given in world coordinates. + + public native void fillContactJacobianMultiDof(int link, + @Const @ByRef btVector3 contact_point, + @Const @ByRef btVector3 normal, + @Cast("btScalar*") FloatPointer jac, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v, + @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + public native void fillContactJacobianMultiDof(int link, + @Const @ByRef btVector3 contact_point, + @Const @ByRef btVector3 normal, + @Cast("btScalar*") FloatBuffer jac, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v, + @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + public native void fillContactJacobianMultiDof(int link, + @Const @ByRef btVector3 contact_point, + @Const @ByRef btVector3 normal, + @Cast("btScalar*") float[] jac, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v, + @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + + //a more general version of fillContactJacobianMultiDof which does not assume.. + //.. that the constraint in question is contact or, to be more precise, constrains linear velocity only + public native void fillConstraintJacobianMultiDof(int link, + @Const @ByRef btVector3 contact_point, + @Const @ByRef btVector3 normal_ang, + @Const @ByRef btVector3 normal_lin, + @Cast("btScalar*") FloatPointer jac, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v, + @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + public native void fillConstraintJacobianMultiDof(int link, + @Const @ByRef btVector3 contact_point, + @Const @ByRef btVector3 normal_ang, + @Const @ByRef btVector3 normal_lin, + @Cast("btScalar*") FloatBuffer jac, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v, + @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + public native void fillConstraintJacobianMultiDof(int link, + @Const @ByRef btVector3 contact_point, + @Const @ByRef btVector3 normal_ang, + @Const @ByRef btVector3 normal_lin, + @Cast("btScalar*") float[] jac, + @ByRef btAlignedObjectArray_btScalar scratch_r, + @ByRef btAlignedObjectArray_btVector3 scratch_v, + @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + + // + // sleeping + // + public native void setCanSleep(@Cast("bool") boolean canSleep); + + public native @Cast("bool") boolean getCanSleep(); + + public native @Cast("bool") boolean getCanWakeup(); + + public native void setCanWakeup(@Cast("bool") boolean canWakeup); + public native @Cast("bool") boolean isAwake(); + public native void wakeUp(); + public native void goToSleep(); + public native void checkMotionAndSleepIfRequired(@Cast("btScalar") float timestep); + + public native @Cast("bool") boolean hasFixedBase(); + + public native @Cast("bool") boolean isBaseKinematic(); + + public native @Cast("bool") boolean isBaseStaticOrKinematic(); + + // set the dynamic type in the base's collision flags. + public native void setBaseDynamicType(int dynamicType); + + public native void setFixedBase(@Cast("bool") boolean fixedBase); + + public native int getCompanionId(); + public native void setCompanionId(int id); + + public native void setNumLinks(int numLinks); + + public native @Cast("btScalar") float getLinearDamping(); + public native void setLinearDamping(@Cast("btScalar") float damp); + public native @Cast("btScalar") float getAngularDamping(); + public native void setAngularDamping(@Cast("btScalar") float damp); + + public native @Cast("bool") boolean getUseGyroTerm(); + public native void setUseGyroTerm(@Cast("bool") boolean useGyro); + public native @Cast("btScalar") float getMaxCoordinateVelocity(); + public native void setMaxCoordinateVelocity(@Cast("btScalar") float maxVel); + + public native @Cast("btScalar") float getMaxAppliedImpulse(); + public native void setMaxAppliedImpulse(@Cast("btScalar") float maxImp); + public native void setHasSelfCollision(@Cast("bool") boolean hasSelfCollision); + public native @Cast("bool") boolean hasSelfCollision(); + + public native void finalizeMultiDof(); + + public native void useRK4Integration(@Cast("bool") boolean use); + public native @Cast("bool") boolean isUsingRK4Integration(); + public native void useGlobalVelocities(@Cast("bool") boolean use); + public native @Cast("bool") boolean isUsingGlobalVelocities(); + + public native @Cast("bool") boolean isPosUpdated(); + public native void setPosUpdated(@Cast("bool") boolean updated); + + //internalNeedsJointFeedback is for internal use only + public native @Cast("bool") boolean internalNeedsJointFeedback(); + public native void forwardKinematics(@ByRef btAlignedObjectArray_btQuaternion world_to_local, @ByRef btAlignedObjectArray_btVector3 local_origin); + + public native void compTreeLinkVelocities(btVector3 omega, btVector3 vel); + + public native void updateCollisionObjectWorldTransforms(@ByRef btAlignedObjectArray_btQuaternion world_to_local, @ByRef btAlignedObjectArray_btVector3 local_origin); + public native void updateCollisionObjectInterpolationWorldTransforms(@ByRef btAlignedObjectArray_btQuaternion world_to_local, @ByRef btAlignedObjectArray_btVector3 local_origin); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); + + public native @Cast("const char*") BytePointer getBaseName(); + /**memory of setBaseName needs to be manager by user */ + public native void setBaseName(@Cast("const char*") BytePointer name); + public native void setBaseName(String name); + + /**users can point to their objects, userPointer is not used by Bullet */ + public native Pointer getUserPointer(); + + public native int getUserIndex(); + + public native int getUserIndex2(); + /**users can point to their objects, userPointer is not used by Bullet */ + public native void setUserPointer(Pointer userPointer); + + /**users can point to their objects, userPointer is not used by Bullet */ + public native void setUserIndex(int index); + + public native void setUserIndex2(int index); + + public static native void spatialTransform(@Const @ByRef btMatrix3x3 rotation_matrix, + @Const @ByRef btVector3 displacement, + @Const @ByRef btVector3 top_in, + @Const @ByRef btVector3 bottom_in, + @ByRef btVector3 top_out, + @ByRef btVector3 bottom_out); // bottom part of output vector + + public native void setLinkDynamicType(int i, int type); + + public native @Cast("bool") boolean isLinkStaticOrKinematic(int i); + + public native @Cast("bool") boolean isLinkKinematic(int i); + + public native @Cast("bool") boolean isLinkAndAllAncestorsStaticOrKinematic(int i); + + public native @Cast("bool") boolean isLinkAndAllAncestorsKinematic(int i); + + public native void setSleepThreshold(@Cast("btScalar") float sleepThreshold); + + public native void setSleepTimeout(@Cast("btScalar") float sleepTimeout); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java new file mode 100644 index 00000000000..0a173d36ffb --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java @@ -0,0 +1,74 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyConstraint extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyConstraint(Pointer p) { super(p); } + + + public native void updateJacobianSizes(); + public native void allocateJacobiansMultiDof(); + + public native int getConstraintType(); + //many constraints have setFrameInB/setPivotInB. Will use 'getConstraintType' later. + public native void setFrameInB(@Const @ByRef btMatrix3x3 frameInB); + public native void setPivotInB(@Const @ByRef btVector3 pivotInB); + + public native void finalizeMultiDof(); + + public native int getIslandIdA(); + public native int getIslandIdB(); + + + + public native int getNumRows(); + + public native btMultiBody getMultiBodyA(); + public native btMultiBody getMultiBodyB(); + + public native int getLinkA(); + public native int getLinkB(); + public native void internalSetAppliedImpulse(int dof, @Cast("btScalar") float appliedImpulse); + + public native @Cast("btScalar") float getAppliedImpulse(int dof); + // current constraint position + // constraint is pos >= 0 for unilateral, or pos = 0 for bilateral + // NOTE: ignored position for friction rows. + public native @Cast("btScalar") float getPosition(int row); + + public native void setPosition(int row, @Cast("btScalar") float pos); + + public native @Cast("bool") boolean isUnilateral(); + + // jacobian blocks. + // each of size 6 + num_links. (jacobian2 is null if no body2.) + // format: 3 'omega' coefficients, 3 'v' coefficients, then the 'qdot' coefficients. + public native @Cast("btScalar*") FloatPointer jacobianA(int row); + public native @Cast("btScalar*") FloatPointer jacobianB(int row); + + public native @Cast("btScalar") float getMaxAppliedImpulse(); + public native void setMaxAppliedImpulse(@Cast("btScalar") float maxImp); + + public native void debugDraw(btIDebugDraw drawer); + + public native void setGearRatio(@Cast("btScalar") float ratio); + public native void setGearAuxLink(int gearAuxLink); + public native void setRelativePositionTarget(@Cast("btScalar") float relPosTarget); + public native void setErp(@Cast("btScalar") float erp); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java new file mode 100644 index 00000000000..89e28c60086 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyConstraintSolver extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btMultiBodyConstraintSolver() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyConstraintSolver(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java new file mode 100644 index 00000000000..03db1342389 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyDoubleData position(long position) { + return (btMultiBodyDoubleData)super.position(position); + } + @Override public btMultiBodyDoubleData getPointer(long i) { + return new btMultiBodyDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3DoubleData m_baseWorldPosition(); public native btMultiBodyDoubleData m_baseWorldPosition(btVector3DoubleData setter); + public native @ByRef btQuaternionDoubleData m_baseWorldOrientation(); public native btMultiBodyDoubleData m_baseWorldOrientation(btQuaternionDoubleData setter); + public native @ByRef btVector3DoubleData m_baseLinearVelocity(); public native btMultiBodyDoubleData m_baseLinearVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_baseAngularVelocity(); public native btMultiBodyDoubleData m_baseAngularVelocity(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_baseInertia(); public native btMultiBodyDoubleData m_baseInertia(btVector3DoubleData setter); // inertia of the base (in local frame; diagonal) + public native double m_baseMass(); public native btMultiBodyDoubleData m_baseMass(double setter); + public native int m_numLinks(); public native btMultiBodyDoubleData m_numLinks(int setter); + public native @Cast("char") byte m_padding(int i); public native btMultiBodyDoubleData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); + + public native @Cast("char*") BytePointer m_baseName(); public native btMultiBodyDoubleData m_baseName(BytePointer setter); + public native btMultiBodyLinkDoubleData m_links(); public native btMultiBodyDoubleData m_links(btMultiBodyLinkDoubleData setter); + public native btCollisionObjectDoubleData m_baseCollider(); public native btMultiBodyDoubleData m_baseCollider(btCollisionObjectDoubleData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java new file mode 100644 index 00000000000..d68f46f2da0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java @@ -0,0 +1,73 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**The btMultiBodyDynamicsWorld adds Featherstone multi body dynamics to Bullet + * This implementation is still preliminary/experimental. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyDynamicsWorld extends btDiscreteDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyDynamicsWorld(Pointer p) { super(p); } + + public btMultiBodyDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); + + public native void solveConstraints(@ByRef btContactSolverInfo solverInfo); + + public native void addMultiBody(btMultiBody body, int group/*=btBroadphaseProxy::DefaultFilter*/, int mask/*=btBroadphaseProxy::AllFilter*/); + public native void addMultiBody(btMultiBody body); + + public native void removeMultiBody(btMultiBody body); + + public native int getNumMultibodies(); + + public native btMultiBody getMultiBody(int mbIndex); + + public native void addMultiBodyConstraint(btMultiBodyConstraint constraint); + + public native int getNumMultiBodyConstraints(); + + public native btMultiBodyConstraint getMultiBodyConstraint(int constraintIndex); + + public native void removeMultiBodyConstraint(btMultiBodyConstraint constraint); + + public native void integrateTransforms(@Cast("btScalar") float timeStep); + public native void integrateMultiBodyTransforms(@Cast("btScalar") float timeStep); + public native void predictMultiBodyTransforms(@Cast("btScalar") float timeStep); + + public native void predictUnconstraintMotion(@Cast("btScalar") float timeStep); + public native void debugDrawWorld(); + + public native void debugDrawMultiBodyConstraint(btMultiBodyConstraint constraint); + + public native void forwardKinematics(); + public native void clearForces(); + public native void clearMultiBodyConstraintForces(); + public native void clearMultiBodyForces(); + public native void applyGravity(); + + public native void serialize(btSerializer serializer); + public native void setMultiBodyConstraintSolver(btMultiBodyConstraintSolver solver); + public native void setConstraintSolver(btConstraintSolver solver); + + + public native void solveExternalForces(@ByRef btContactSolverInfo solverInfo); + public native void solveInternalConstraints(@ByRef btContactSolverInfo solverInfo); + public native void buildIslands(); + + public native void saveKinematicState(@Cast("btScalar") float timeStep); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java new file mode 100644 index 00000000000..b54ebbb32e9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyFloatData position(long position) { + return (btMultiBodyFloatData)super.position(position); + } + @Override public btMultiBodyFloatData getPointer(long i) { + return new btMultiBodyFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_baseWorldPosition(); public native btMultiBodyFloatData m_baseWorldPosition(btVector3FloatData setter); + public native @ByRef btQuaternionFloatData m_baseWorldOrientation(); public native btMultiBodyFloatData m_baseWorldOrientation(btQuaternionFloatData setter); + public native @ByRef btVector3FloatData m_baseLinearVelocity(); public native btMultiBodyFloatData m_baseLinearVelocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_baseAngularVelocity(); public native btMultiBodyFloatData m_baseAngularVelocity(btVector3FloatData setter); + + public native @ByRef btVector3FloatData m_baseInertia(); public native btMultiBodyFloatData m_baseInertia(btVector3FloatData setter); // inertia of the base (in local frame; diagonal) + public native float m_baseMass(); public native btMultiBodyFloatData m_baseMass(float setter); + public native int m_numLinks(); public native btMultiBodyFloatData m_numLinks(int setter); + + public native @Cast("char*") BytePointer m_baseName(); public native btMultiBodyFloatData m_baseName(BytePointer setter); + public native btMultiBodyLinkFloatData m_links(); public native btMultiBodyFloatData m_links(btMultiBodyLinkFloatData setter); + public native btCollisionObjectFloatData m_baseCollider(); public native btMultiBodyFloatData m_baseCollider(btCollisionObjectFloatData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java new file mode 100644 index 00000000000..92b58d46a4b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyJacobianData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyJacobianData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyJacobianData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyJacobianData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyJacobianData position(long position) { + return (btMultiBodyJacobianData)super.position(position); + } + @Override public btMultiBodyJacobianData getPointer(long i) { + return new btMultiBodyJacobianData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btAlignedObjectArray_btScalar m_jacobians(); public native btMultiBodyJacobianData m_jacobians(btAlignedObjectArray_btScalar setter); + public native @ByRef btAlignedObjectArray_btScalar m_deltaVelocitiesUnitImpulse(); public native btMultiBodyJacobianData m_deltaVelocitiesUnitImpulse(btAlignedObjectArray_btScalar setter); //holds the joint-space response of the corresp. tree to the test impulse in each constraint space dimension + public native @ByRef btAlignedObjectArray_btScalar m_deltaVelocities(); public native btMultiBodyJacobianData m_deltaVelocities(btAlignedObjectArray_btScalar setter); //holds joint-space vectors of all the constrained trees accumulating the effect of corrective impulses applied in SI + public native @ByRef btAlignedObjectArray_btScalar scratch_r(); public native btMultiBodyJacobianData scratch_r(btAlignedObjectArray_btScalar setter); + public native @ByRef btAlignedObjectArray_btVector3 scratch_v(); public native btMultiBodyJacobianData scratch_v(btAlignedObjectArray_btVector3 setter); + public native @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m(); public native btMultiBodyJacobianData scratch_m(btAlignedObjectArray_btMatrix3x3 setter); + + public native int m_fixedBodyId(); public native btMultiBodyJacobianData m_fixedBodyId(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointFeedback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointFeedback.java new file mode 100644 index 00000000000..8d78d441600 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointFeedback.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyJointFeedback extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyJointFeedback() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyJointFeedback(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyJointFeedback(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyJointFeedback position(long position) { + return (btMultiBodyJointFeedback)super.position(position); + } + @Override public btMultiBodyJointFeedback getPointer(long i) { + return new btMultiBodyJointFeedback((Pointer)this).offsetAddress(i); + } + + public native @ByRef btSpatialForceVector m_reactionForces(); public native btMultiBodyJointFeedback m_reactionForces(btSpatialForceVector setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java new file mode 100644 index 00000000000..6b599d876fe --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyLinkCollider extends btCollisionObject { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyLinkCollider(Pointer p) { super(p); } + + public native btMultiBody m_multiBody(); public native btMultiBodyLinkCollider m_multiBody(btMultiBody setter); + public native int m_link(); public native btMultiBodyLinkCollider m_link(int setter); + public btMultiBodyLinkCollider(btMultiBody multiBody, int link) { super((Pointer)null); allocate(multiBody, link); } + private native void allocate(btMultiBody multiBody, int link); + public static native btMultiBodyLinkCollider upcast(btCollisionObject colObj); + + public native @Cast("bool") boolean checkCollideWithOverride(@Const btCollisionObject co); + + public native @Cast("bool") boolean isStaticOrKinematic(); + + public native @Cast("bool") boolean isKinematic(); + + public native void setDynamicType(int dynamicType); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderDoubleData.java new file mode 100644 index 00000000000..ce5f3b65339 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderDoubleData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyLinkColliderDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyLinkColliderDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyLinkColliderDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyLinkColliderDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyLinkColliderDoubleData position(long position) { + return (btMultiBodyLinkColliderDoubleData)super.position(position); + } + @Override public btMultiBodyLinkColliderDoubleData getPointer(long i) { + return new btMultiBodyLinkColliderDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionObjectDoubleData m_colObjData(); public native btMultiBodyLinkColliderDoubleData m_colObjData(btCollisionObjectDoubleData setter); + public native btMultiBodyDoubleData m_multiBody(); public native btMultiBodyLinkColliderDoubleData m_multiBody(btMultiBodyDoubleData setter); + public native int m_link(); public native btMultiBodyLinkColliderDoubleData m_link(int setter); + public native @Cast("char") byte m_padding(int i); public native btMultiBodyLinkColliderDoubleData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java new file mode 100644 index 00000000000..8b7796cf58c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +// clang-format off + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyLinkColliderFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyLinkColliderFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyLinkColliderFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyLinkColliderFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyLinkColliderFloatData position(long position) { + return (btMultiBodyLinkColliderFloatData)super.position(position); + } + @Override public btMultiBodyLinkColliderFloatData getPointer(long i) { + return new btMultiBodyLinkColliderFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionObjectFloatData m_colObjData(); public native btMultiBodyLinkColliderFloatData m_colObjData(btCollisionObjectFloatData setter); + public native btMultiBodyFloatData m_multiBody(); public native btMultiBodyLinkColliderFloatData m_multiBody(btMultiBodyFloatData setter); + public native int m_link(); public native btMultiBodyLinkColliderFloatData m_link(int setter); + public native @Cast("char") byte m_padding(int i); public native btMultiBodyLinkColliderFloatData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkDoubleData.java new file mode 100644 index 00000000000..acdfdaa82b1 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkDoubleData.java @@ -0,0 +1,74 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyLinkDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyLinkDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyLinkDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyLinkDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyLinkDoubleData position(long position) { + return (btMultiBodyLinkDoubleData)super.position(position); + } + @Override public btMultiBodyLinkDoubleData getPointer(long i) { + return new btMultiBodyLinkDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btQuaternionDoubleData m_zeroRotParentToThis(); public native btMultiBodyLinkDoubleData m_zeroRotParentToThis(btQuaternionDoubleData setter); + public native @ByRef btVector3DoubleData m_parentComToThisPivotOffset(); public native btMultiBodyLinkDoubleData m_parentComToThisPivotOffset(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_thisPivotToThisComOffset(); public native btMultiBodyLinkDoubleData m_thisPivotToThisComOffset(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_jointAxisTop(int i); public native btMultiBodyLinkDoubleData m_jointAxisTop(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_jointAxisTop(); + public native @ByRef btVector3DoubleData m_jointAxisBottom(int i); public native btMultiBodyLinkDoubleData m_jointAxisBottom(int i, btVector3DoubleData setter); + @MemberGetter public native btVector3DoubleData m_jointAxisBottom(); + + public native @ByRef btVector3DoubleData m_linkInertia(); public native btMultiBodyLinkDoubleData m_linkInertia(btVector3DoubleData setter); // inertia of the base (in local frame; diagonal) + public native @ByRef btVector3DoubleData m_absFrameTotVelocityTop(); public native btMultiBodyLinkDoubleData m_absFrameTotVelocityTop(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_absFrameTotVelocityBottom(); public native btMultiBodyLinkDoubleData m_absFrameTotVelocityBottom(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_absFrameLocVelocityTop(); public native btMultiBodyLinkDoubleData m_absFrameLocVelocityTop(btVector3DoubleData setter); + public native @ByRef btVector3DoubleData m_absFrameLocVelocityBottom(); public native btMultiBodyLinkDoubleData m_absFrameLocVelocityBottom(btVector3DoubleData setter); + + public native double m_linkMass(); public native btMultiBodyLinkDoubleData m_linkMass(double setter); + public native int m_parentIndex(); public native btMultiBodyLinkDoubleData m_parentIndex(int setter); + public native int m_jointType(); public native btMultiBodyLinkDoubleData m_jointType(int setter); + + public native int m_dofCount(); public native btMultiBodyLinkDoubleData m_dofCount(int setter); + public native int m_posVarCount(); public native btMultiBodyLinkDoubleData m_posVarCount(int setter); + public native double m_jointPos(int i); public native btMultiBodyLinkDoubleData m_jointPos(int i, double setter); + @MemberGetter public native DoublePointer m_jointPos(); + public native double m_jointVel(int i); public native btMultiBodyLinkDoubleData m_jointVel(int i, double setter); + @MemberGetter public native DoublePointer m_jointVel(); + public native double m_jointTorque(int i); public native btMultiBodyLinkDoubleData m_jointTorque(int i, double setter); + @MemberGetter public native DoublePointer m_jointTorque(); + + public native double m_jointDamping(); public native btMultiBodyLinkDoubleData m_jointDamping(double setter); + public native double m_jointFriction(); public native btMultiBodyLinkDoubleData m_jointFriction(double setter); + public native double m_jointLowerLimit(); public native btMultiBodyLinkDoubleData m_jointLowerLimit(double setter); + public native double m_jointUpperLimit(); public native btMultiBodyLinkDoubleData m_jointUpperLimit(double setter); + public native double m_jointMaxForce(); public native btMultiBodyLinkDoubleData m_jointMaxForce(double setter); + public native double m_jointMaxVelocity(); public native btMultiBodyLinkDoubleData m_jointMaxVelocity(double setter); + + public native @Cast("char*") BytePointer m_linkName(); public native btMultiBodyLinkDoubleData m_linkName(BytePointer setter); + public native @Cast("char*") BytePointer m_jointName(); public native btMultiBodyLinkDoubleData m_jointName(BytePointer setter); + public native btCollisionObjectDoubleData m_linkCollider(); public native btMultiBodyLinkDoubleData m_linkCollider(btCollisionObjectDoubleData setter); + public native @Cast("char*") BytePointer m_paddingPtr(); public native btMultiBodyLinkDoubleData m_paddingPtr(BytePointer setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkFloatData.java new file mode 100644 index 00000000000..0ab8fde2a3e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkFloatData.java @@ -0,0 +1,72 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyLinkFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyLinkFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyLinkFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyLinkFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyLinkFloatData position(long position) { + return (btMultiBodyLinkFloatData)super.position(position); + } + @Override public btMultiBodyLinkFloatData getPointer(long i) { + return new btMultiBodyLinkFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btQuaternionFloatData m_zeroRotParentToThis(); public native btMultiBodyLinkFloatData m_zeroRotParentToThis(btQuaternionFloatData setter); + public native @ByRef btVector3FloatData m_parentComToThisPivotOffset(); public native btMultiBodyLinkFloatData m_parentComToThisPivotOffset(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_thisPivotToThisComOffset(); public native btMultiBodyLinkFloatData m_thisPivotToThisComOffset(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_jointAxisTop(int i); public native btMultiBodyLinkFloatData m_jointAxisTop(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_jointAxisTop(); + public native @ByRef btVector3FloatData m_jointAxisBottom(int i); public native btMultiBodyLinkFloatData m_jointAxisBottom(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_jointAxisBottom(); + public native @ByRef btVector3FloatData m_linkInertia(); public native btMultiBodyLinkFloatData m_linkInertia(btVector3FloatData setter); // inertia of the base (in local frame; diagonal) + public native @ByRef btVector3FloatData m_absFrameTotVelocityTop(); public native btMultiBodyLinkFloatData m_absFrameTotVelocityTop(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_absFrameTotVelocityBottom(); public native btMultiBodyLinkFloatData m_absFrameTotVelocityBottom(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_absFrameLocVelocityTop(); public native btMultiBodyLinkFloatData m_absFrameLocVelocityTop(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_absFrameLocVelocityBottom(); public native btMultiBodyLinkFloatData m_absFrameLocVelocityBottom(btVector3FloatData setter); + + public native int m_dofCount(); public native btMultiBodyLinkFloatData m_dofCount(int setter); + public native float m_linkMass(); public native btMultiBodyLinkFloatData m_linkMass(float setter); + public native int m_parentIndex(); public native btMultiBodyLinkFloatData m_parentIndex(int setter); + public native int m_jointType(); public native btMultiBodyLinkFloatData m_jointType(int setter); + + public native float m_jointPos(int i); public native btMultiBodyLinkFloatData m_jointPos(int i, float setter); + @MemberGetter public native FloatPointer m_jointPos(); + public native float m_jointVel(int i); public native btMultiBodyLinkFloatData m_jointVel(int i, float setter); + @MemberGetter public native FloatPointer m_jointVel(); + public native float m_jointTorque(int i); public native btMultiBodyLinkFloatData m_jointTorque(int i, float setter); + @MemberGetter public native FloatPointer m_jointTorque(); + public native int m_posVarCount(); public native btMultiBodyLinkFloatData m_posVarCount(int setter); + public native float m_jointDamping(); public native btMultiBodyLinkFloatData m_jointDamping(float setter); + public native float m_jointFriction(); public native btMultiBodyLinkFloatData m_jointFriction(float setter); + public native float m_jointLowerLimit(); public native btMultiBodyLinkFloatData m_jointLowerLimit(float setter); + public native float m_jointUpperLimit(); public native btMultiBodyLinkFloatData m_jointUpperLimit(float setter); + public native float m_jointMaxForce(); public native btMultiBodyLinkFloatData m_jointMaxForce(float setter); + public native float m_jointMaxVelocity(); public native btMultiBodyLinkFloatData m_jointMaxVelocity(float setter); + + public native @Cast("char*") BytePointer m_linkName(); public native btMultiBodyLinkFloatData m_linkName(BytePointer setter); + public native @Cast("char*") BytePointer m_jointName(); public native btMultiBodyLinkFloatData m_jointName(BytePointer setter); + public native btCollisionObjectFloatData m_linkCollider(); public native btMultiBodyLinkFloatData m_linkCollider(btCollisionObjectFloatData setter); + public native @Cast("char*") BytePointer m_paddingPtr(); public native btMultiBodyLinkFloatData m_paddingPtr(BytePointer setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java new file mode 100644 index 00000000000..fff0debe7cf --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java @@ -0,0 +1,154 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +//} + +// +// Link struct +// + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultibodyLink extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultibodyLink(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultibodyLink(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMultibodyLink position(long position) { + return (btMultibodyLink)super.position(position); + } + @Override public btMultibodyLink getPointer(long i) { + return new btMultibodyLink((Pointer)this).offsetAddress(i); + } + + + public native @Cast("btScalar") float m_mass(); public native btMultibodyLink m_mass(float setter); // mass of link + public native @ByRef btVector3 m_inertiaLocal(); public native btMultibodyLink m_inertiaLocal(btVector3 setter); // inertia of link (local frame; diagonal) + + public native int m_parent(); public native btMultibodyLink m_parent(int setter); // index of the parent link (assumed to be < index of this link), or -1 if parent is the base link. + + public native @ByRef btQuaternion m_zeroRotParentToThis(); public native btMultibodyLink m_zeroRotParentToThis(btQuaternion setter); // rotates vectors in parent-frame to vectors in local-frame (when q=0). constant. + + public native @ByRef btVector3 m_dVector(); public native btMultibodyLink m_dVector(btVector3 setter); // vector from the inboard joint pos to this link's COM. (local frame.) constant. + //this is set to zero for planar joint (see also m_eVector comment) + + // m_eVector is constant, but depends on the joint type: + // revolute, fixed, prismatic, spherical: vector from parent's COM to the pivot point, in PARENT's frame. + // planar: vector from COM of parent to COM of this link, WHEN Q = 0. (local frame.) + // todo: fix the planar so it is consistent with the other joints + + public native @ByRef btVector3 m_eVector(); public native btMultibodyLink m_eVector(btVector3 setter); + + public native @ByRef btSpatialMotionVector m_absFrameTotVelocity(); public native btMultibodyLink m_absFrameTotVelocity(btSpatialMotionVector setter); + public native @ByRef btSpatialMotionVector m_absFrameLocVelocity(); public native btMultibodyLink m_absFrameLocVelocity(btSpatialMotionVector setter); + + /** enum btMultibodyLink::eFeatherstoneJointType */ + public static final int + eRevolute = 0, + ePrismatic = 1, + eSpherical = 2, + ePlanar = 3, + eFixed = 4, + eInvalid = 5; + + // "axis" = spatial joint axis (Mirtich Defn 9 p104). (expressed in local frame.) constant. + // for prismatic: m_axesTop[0] = zero; + // m_axesBottom[0] = unit vector along the joint axis. + // for revolute: m_axesTop[0] = unit vector along the rotation axis (u); + // m_axesBottom[0] = u cross m_dVector (i.e. COM linear motion due to the rotation at the joint) + // + // for spherical: m_axesTop[0][1][2] (u1,u2,u3) form a 3x3 identity matrix (3 rotation axes) + // m_axesBottom[0][1][2] cross u1,u2,u3 (i.e. COM linear motion due to the rotation at the joint) + // + // for planar: m_axesTop[0] = unit vector along the rotation axis (u); defines the plane of motion + // m_axesTop[1][2] = zero + // m_axesBottom[0] = zero + // m_axesBottom[1][2] = unit vectors along the translational axes on that plane + public native @ByRef btSpatialMotionVector m_axes(int i); public native btMultibodyLink m_axes(int i, btSpatialMotionVector setter); + @MemberGetter public native btSpatialMotionVector m_axes(); + public native void setAxisTop(int dof, @Const @ByRef btVector3 axis); + public native void setAxisBottom(int dof, @Const @ByRef btVector3 axis); + public native void setAxisTop(int dof, @Cast("const btScalar") float x, @Cast("const btScalar") float y, @Cast("const btScalar") float z); + public native void setAxisBottom(int dof, @Cast("const btScalar") float x, @Cast("const btScalar") float y, @Cast("const btScalar") float z); + public native @Const @ByRef btVector3 getAxisTop(int dof); + public native @Const @ByRef btVector3 getAxisBottom(int dof); + + public native int m_dofOffset(); public native btMultibodyLink m_dofOffset(int setter); + public native int m_cfgOffset(); public native btMultibodyLink m_cfgOffset(int setter); + + public native @ByRef btQuaternion m_cachedRotParentToThis(); public native btMultibodyLink m_cachedRotParentToThis(btQuaternion setter); // rotates vectors in parent frame to vectors in local frame + public native @ByRef btVector3 m_cachedRVector(); public native btMultibodyLink m_cachedRVector(btVector3 setter); // vector from COM of parent to COM of this link, in local frame. + + // predicted verstion + public native @ByRef btQuaternion m_cachedRotParentToThis_interpolate(); public native btMultibodyLink m_cachedRotParentToThis_interpolate(btQuaternion setter); // rotates vectors in parent frame to vectors in local frame + public native @ByRef btVector3 m_cachedRVector_interpolate(); public native btMultibodyLink m_cachedRVector_interpolate(btVector3 setter); // vector from COM of parent to COM of this link, in local frame. + + public native @ByRef btVector3 m_appliedForce(); public native btMultibodyLink m_appliedForce(btVector3 setter); // In WORLD frame + public native @ByRef btVector3 m_appliedTorque(); public native btMultibodyLink m_appliedTorque(btVector3 setter); // In WORLD frame + + public native @ByRef btVector3 m_appliedConstraintForce(); public native btMultibodyLink m_appliedConstraintForce(btVector3 setter); // In WORLD frame + public native @ByRef btVector3 m_appliedConstraintTorque(); public native btMultibodyLink m_appliedConstraintTorque(btVector3 setter); // In WORLD frame + + public native @Cast("btScalar") float m_jointPos(int i); public native btMultibodyLink m_jointPos(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_jointPos(); + public native @Cast("btScalar") float m_jointPos_interpolate(int i); public native btMultibodyLink m_jointPos_interpolate(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_jointPos_interpolate(); + + //m_jointTorque is the joint torque applied by the user using 'addJointTorque'. + //It gets set to zero after each internal stepSimulation call + public native @Cast("btScalar") float m_jointTorque(int i); public native btMultibodyLink m_jointTorque(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_jointTorque(); + + public native btMultiBodyLinkCollider m_collider(); public native btMultibodyLink m_collider(btMultiBodyLinkCollider setter); + public native int m_flags(); public native btMultibodyLink m_flags(int setter); + + public native int m_dofCount(); public native btMultibodyLink m_dofCount(int setter); + public native int m_posVarCount(); public native btMultibodyLink m_posVarCount(int setter); //redundant but handy + + public native @Cast("btMultibodyLink::eFeatherstoneJointType") int m_jointType(); public native btMultibodyLink m_jointType(int setter); + + public native btMultiBodyJointFeedback m_jointFeedback(); public native btMultibodyLink m_jointFeedback(btMultiBodyJointFeedback setter); + + public native @ByRef btTransform m_cachedWorldTransform(); public native btMultibodyLink m_cachedWorldTransform(btTransform setter); //this cache is updated when calling btMultiBody::forwardKinematics + + public native @Cast("const char*") BytePointer m_linkName(); public native btMultibodyLink m_linkName(BytePointer setter); //m_linkName memory needs to be managed by the developer/user! + public native @Cast("const char*") BytePointer m_jointName(); public native btMultibodyLink m_jointName(BytePointer setter); //m_jointName memory needs to be managed by the developer/user! + public native @Const Pointer m_userPtr(); public native btMultibodyLink m_userPtr(Pointer setter); //m_userPtr ptr needs to be managed by the developer/user! + + public native @Cast("btScalar") float m_jointDamping(); public native btMultibodyLink m_jointDamping(float setter); //todo: implement this internally. It is unused for now, it is set by a URDF loader. User can apply manual damping. + public native @Cast("btScalar") float m_jointFriction(); public native btMultibodyLink m_jointFriction(float setter); //todo: implement this internally. It is unused for now, it is set by a URDF loader. User can apply manual friction using a velocity motor. + public native @Cast("btScalar") float m_jointLowerLimit(); public native btMultibodyLink m_jointLowerLimit(float setter); //todo: implement this internally. It is unused for now, it is set by a URDF loader. + public native @Cast("btScalar") float m_jointUpperLimit(); public native btMultibodyLink m_jointUpperLimit(float setter); //todo: implement this internally. It is unused for now, it is set by a URDF loader. + public native @Cast("btScalar") float m_jointMaxForce(); public native btMultibodyLink m_jointMaxForce(float setter); //todo: implement this internally. It is unused for now, it is set by a URDF loader. + public native @Cast("btScalar") float m_jointMaxVelocity(); public native btMultibodyLink m_jointMaxVelocity(float setter); //todo: implement this internally. It is unused for now, it is set by a URDF loader. + + // ctor: set some sensible defaults + public btMultibodyLink() { super((Pointer)null); allocate(); } + private native void allocate(); + + // routine to update m_cachedRotParentToThis and m_cachedRVector + public native void updateCacheMultiDof(@Cast("btScalar*") FloatPointer pq/*=0*/); + public native void updateCacheMultiDof(); + public native void updateCacheMultiDof(@Cast("btScalar*") FloatBuffer pq/*=0*/); + public native void updateCacheMultiDof(@Cast("btScalar*") float[] pq/*=0*/); + + public native void updateInterpolationCacheMultiDof(); + + + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPersistentManifold.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java similarity index 81% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPersistentManifold.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java index 09aa959a2f0..96d3dd2d978 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPersistentManifold.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java @@ -15,9 +15,9 @@ import static org.bytedeco.bullet.global.BulletDynamics.*; @Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btPersistentManifold extends Pointer { +public class btSolverInfo extends Pointer { /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btPersistentManifold() { super((Pointer)null); } + public btSolverInfo() { super((Pointer)null); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPersistentManifold(Pointer p) { super(p); } + public btSolverInfo(Pointer p) { super(p); } } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java new file mode 100644 index 00000000000..3779e9ccf3f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class DeformableBodyInplaceSolverIslandCallback extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public DeformableBodyInplaceSolverIslandCallback() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DeformableBodyInplaceSolverIslandCallback(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java new file mode 100644 index 00000000000..2ccaf0772b2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class MultiBodyInplaceSolverIslandCallback extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public MultiBodyInplaceSolverIslandCallback() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public MultiBodyInplaceSolverIslandCallback(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java new file mode 100644 index 00000000000..90d26c237a0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java @@ -0,0 +1,96 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody position(long position) { + return (btAlignedObjectArray_btSoftBody)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody getPointer(long i) { + return new btAlignedObjectArray_btSoftBody((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody put(@Const @ByRef btAlignedObjectArray_btSoftBody other); + public btAlignedObjectArray_btSoftBody() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody(@Const @ByRef btAlignedObjectArray_btSoftBody otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btSoftBody at(int n); + + public native @ByPtrRef @Name("operator []") btSoftBody get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btSoftBody fillData/*=btSoftBody*()*/); + public native void resize(int newsize); + public native @ByPtrRef btSoftBody expandNonInitializing(); + + public native @ByPtrRef btSoftBody expand(@ByPtrRef btSoftBody fillValue/*=btSoftBody*()*/); + public native @ByPtrRef btSoftBody expand(); + + public native void push_back(@ByPtrRef btSoftBody _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btSoftBody key); + + public native int findLinearSearch(@ByPtrRef btSoftBody key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btSoftBody key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btSoftBody key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java new file mode 100644 index 00000000000..cf608afdc30 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btCollisionObjectWrapper extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btCollisionObjectWrapper() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionObjectWrapper(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java new file mode 100644 index 00000000000..3fb0ea47f80 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableBackwardEulerObjective extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btDeformableBackwardEulerObjective() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableBackwardEulerObjective(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java new file mode 100644 index 00000000000..59d47845f87 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java @@ -0,0 +1,137 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableBodySolver extends btSoftBodySolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableBodySolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableBodySolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableBodySolver position(long position) { + return (btDeformableBodySolver)super.position(position); + } + @Override public btDeformableBodySolver getPointer(long i) { + return new btDeformableBodySolver((Pointer)this).offsetAddress(i); + } + + // handles data related to objective function + public native btDeformableBackwardEulerObjective m_objective(); public native btDeformableBodySolver m_objective(btDeformableBackwardEulerObjective setter); + public native @Cast("bool") boolean m_useProjection(); public native btDeformableBodySolver m_useProjection(boolean setter); + + public btDeformableBodySolver() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @ByVal SolverTypes getSolverType(); + + // update soft body normals + public native void updateSoftBodies(); + + public native @Cast("btScalar") float solveContactConstraints(@Cast("btCollisionObject**") PointerPointer deformableBodies, int numDeformableBodies, @Const @ByRef btContactSolverInfo infoGlobal); + public native @Cast("btScalar") float solveContactConstraints(@ByPtrPtr btCollisionObject deformableBodies, int numDeformableBodies, @Const @ByRef btContactSolverInfo infoGlobal); + + // solve the momentum equation + public native void solveDeformableConstraints(@Cast("btScalar") float solverdt); + + // resize/clear data structures + public native void reinitialize(@Const @ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("btScalar") float dt); + + // set up contact constraints + public native void setConstraints(@Const @ByRef btContactSolverInfo infoGlobal); + + // add in elastic forces and gravity to obtain v_{n+1}^* and calls predictDeformableMotion + public native void predictMotion(@Cast("btScalar") float solverdt); + + // move to temporary position x_{n+1}^* = x_n + dt * v_{n+1}^* + // x_{n+1}^* is stored in m_q + public native void predictDeformableMotion(btSoftBody psb, @Cast("btScalar") float dt); + + // save the current velocity to m_backupVelocity + public native void backupVelocity(); + + // set m_dv and m_backupVelocity to desired value to prepare for momentum solve + public native void setupDeformableSolve(@Cast("bool") boolean implicit); + + // set the current velocity to that backed up in m_backupVelocity + public native void revertVelocity(); + + // set velocity to m_dv + m_backupVelocity + public native void updateVelocity(); + + // update the node count + public native @Cast("bool") boolean updateNodes(); + + // calculate the change in dv resulting from the momentum solve + + + // calculate the change in dv resulting from the momentum solve when line search is turned on + + + public native void copySoftBodyToVertexBuffer(@Const btSoftBody softBody, btVertexBufferDescriptor vertexBuffer); + + // process collision between deformable and rigid + public native void processCollision(btSoftBody softBody, @Const btCollisionObjectWrapper collisionObjectWrap); + + // process collision between deformable and deformable + public native void processCollision(btSoftBody softBody, btSoftBody otherSoftBody); + + // If true, implicit time stepping scheme is used. + // Otherwise, explicit time stepping scheme is used + public native void setImplicit(@Cast("bool") boolean implicit); + + // If true, newton's method with line search is used when implicit time stepping scheme is turned on + public native void setLineSearch(@Cast("bool") boolean lineSearch); + + // set temporary position x^* = x_n + dt * v + // update the deformation gradient at position x^* + public native void updateState(); + + // set dv = dv + scale * ddv + public native void updateDv(@Cast("btScalar") float scale/*=1*/); + public native void updateDv(); + + // set temporary position x^* = x_n + dt * v^* + public native void updateTempPosition(); + + // save the current dv to m_backup_dv; + public native void backupDv(); + + // set dv to the backed-up value + public native void revertDv(); + + // set dv = dv + scale * ddv + // set v^* = v_n + dv + // set temporary position x^* = x_n + dt * v^* + // update the deformation gradient at position x^* + public native void updateEnergy(@Cast("btScalar") float scale); + + // calculates the appropriately scaled kinetic energy in the system, which is + // 1/2 * dv^T * M * dv + // used in line search + public native @Cast("btScalar") float kineticEnergy(); + + // unused functions + public native void optimize(@ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("bool") boolean forceUpdate/*=false*/); + public native void optimize(@ByRef btAlignedObjectArray_btSoftBody softBodies); + public native void solveConstraints(@Cast("btScalar") float dt); + public native @Cast("bool") boolean checkInitialized(); + public native void copyBackToSoftBodies(@Cast("bool") boolean bMove/*=true*/); + public native void copyBackToSoftBodies(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java new file mode 100644 index 00000000000..01fa19734ff --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableLagrangianForce extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btDeformableLagrangianForce() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableLagrangianForce(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.java new file mode 100644 index 00000000000..73756490549 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// btDeformableMultiBodyConstraintSolver extendsn btMultiBodyConstraintSolver to solve for the contact among rigid/multibody and deformable bodies. Notice that the following constraints +// 1. rigid/multibody against rigid/multibody +// 2. rigid/multibody against deforamble +// 3. deformable against deformable +// 4. deformable self collision +// 5. joint constraints +// are all coupled in this solve. +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableMultiBodyConstraintSolver extends btMultiBodyConstraintSolver { + static { Loader.load(); } + /** Default native constructor. */ + public btDeformableMultiBodyConstraintSolver() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableMultiBodyConstraintSolver(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableMultiBodyConstraintSolver(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btDeformableMultiBodyConstraintSolver position(long position) { + return (btDeformableMultiBodyConstraintSolver)super.position(position); + } + @Override public btDeformableMultiBodyConstraintSolver getPointer(long i) { + return new btDeformableMultiBodyConstraintSolver((Pointer)this).offsetAddress(i); + } + + + public native void setDeformableSolver(btDeformableBodySolver deformableSolver); + + public native void solveDeformableBodyGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btCollisionObject**") PointerPointer deformableBodies, int numDeformableBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Cast("btMultiBodyConstraint**") PointerPointer multiBodyConstraints, int numMultiBodyConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + public native void solveDeformableBodyGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btCollisionObject deformableBodies, int numDeformableBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @ByPtrPtr btMultiBodyConstraint multiBodyConstraints, int numMultiBodyConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java new file mode 100644 index 00000000000..98793147762 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java @@ -0,0 +1,117 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableMultiBodyDynamicsWorld(Pointer p) { super(p); } + + public btDeformableMultiBodyDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btDeformableMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btDeformableBodySolver deformableBodySolver/*=0*/) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration, deformableBodySolver); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btDeformableMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btDeformableBodySolver deformableBodySolver/*=0*/); + public btDeformableMultiBodyDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btDeformableMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btDeformableMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); + + public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps/*=1*/, @Cast("btScalar") float fixedTimeStep/*=btScalar(1.) / btScalar(60.)*/); + public native int stepSimulation(@Cast("btScalar") float timeStep); + + public native void debugDrawWorld(); + + + + public native btMultiBodyDynamicsWorld getMultiBodyDynamicsWorld(); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + public native void predictUnconstraintMotion(@Cast("btScalar") float timeStep); + + public native void addSoftBody(btSoftBody body, int collisionFilterGroup/*=btBroadphaseProxy::DefaultFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter*/); + public native void addSoftBody(btSoftBody body); + + public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBody getSoftBodyArray(); + + public native @ByRef btSoftBodyWorldInfo getWorldInfo(); + + public native void reinitialize(@Cast("btScalar") float timeStep); + + public native void applyRigidBodyGravity(@Cast("btScalar") float timeStep); + + public native void beforeSolverCallbacks(@Cast("btScalar") float timeStep); + + public native void afterSolverCallbacks(@Cast("btScalar") float timeStep); + + public native void addForce(btSoftBody psb, btDeformableLagrangianForce force); + + public native void removeForce(btSoftBody psb, btDeformableLagrangianForce force); + + public native void removeSoftBodyForce(btSoftBody psb); + + public native void removeSoftBody(btSoftBody body); + + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native int getDrawFlags(); + public native void setDrawFlags(int f); + + public native void setupConstraints(); + + public native void performDeformableCollisionDetection(); + + public native void solveMultiBodyConstraints(); + + public native void solveContactConstraints(); + + public native void sortConstraints(); + + public native void softBodySelfCollision(); + + public native void setImplicit(@Cast("bool") boolean implicit); + + public native void setLineSearch(@Cast("bool") boolean lineSearch); + + public native void setUseProjection(@Cast("bool") boolean useProjection); + + public native void applyRepulsionForce(@Cast("btScalar") float timeStep); + + public native void performGeometricCollisions(@Cast("btScalar") float timeStep); + + @NoOffset public static class btDeformableSingleRayCallback extends btBroadphaseRayCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableSingleRayCallback(Pointer p) { super(p); } + + public native @ByRef btVector3 m_rayFromWorld(); public native btDeformableSingleRayCallback m_rayFromWorld(btVector3 setter); + public native @ByRef btVector3 m_rayToWorld(); public native btDeformableSingleRayCallback m_rayToWorld(btVector3 setter); + public native @ByRef btTransform m_rayFromTrans(); public native btDeformableSingleRayCallback m_rayFromTrans(btTransform setter); + public native @ByRef btTransform m_rayToTrans(); public native btDeformableSingleRayCallback m_rayToTrans(btTransform setter); + public native @ByRef btVector3 m_hitNormal(); public native btDeformableSingleRayCallback m_hitNormal(btVector3 setter); + + public native @Const btDeformableMultiBodyDynamicsWorld m_world(); public native btDeformableSingleRayCallback m_world(btDeformableMultiBodyDynamicsWorld setter); + public native @ByRef btCollisionWorld.RayResultCallback m_resultCallback(); public native btDeformableSingleRayCallback m_resultCallback(btCollisionWorld.RayResultCallback setter); + + public btDeformableSingleRayCallback(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @Const btDeformableMultiBodyDynamicsWorld world, @ByRef btCollisionWorld.RayResultCallback resultCallback) { super((Pointer)null); allocate(rayFromWorld, rayToWorld, world, resultCallback); } + private native void allocate(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @Const btDeformableMultiBodyDynamicsWorld world, @ByRef btCollisionWorld.RayResultCallback resultCallback); + + public native @Cast("bool") boolean process(@Const btBroadphaseProxy proxy); + } + + public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); + + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btGjkEpaPenetrationDepthSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btGjkEpaPenetrationDepthSolver.java new file mode 100644 index 00000000000..afcce40af25 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btGjkEpaPenetrationDepthSolver.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btGjkEpaPenetrationDepthSolver extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btGjkEpaPenetrationDepthSolver() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGjkEpaPenetrationDepthSolver(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java new file mode 100644 index 00000000000..42902a6275e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java @@ -0,0 +1,1673 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/**The btSoftBody is an class to simulate cloth and volumetric soft bodies. + * There is two-way interaction between btSoftBody and btRigidBody/btCollisionObject. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBody extends btCollisionObject { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBody(Pointer p) { super(p); } + + + + // The solver object that handles this soft body + public native btSoftBodySolver m_softBodySolver(); public native btSoftBody m_softBodySolver(btSoftBodySolver setter); + + // + // Enumerations + // + + /**eAeroModel */ + public static class eAeroModel extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public eAeroModel() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public eAeroModel(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public eAeroModel(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public eAeroModel position(long position) { + return (eAeroModel)super.position(position); + } + @Override public eAeroModel getPointer(long i) { + return new eAeroModel((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::eAeroModel::_ */ + public static final int + V_Point = 0, /**Vertex normals are oriented toward velocity */ + V_TwoSided = 1, /**Vertex normals are flipped to match velocity */ + V_TwoSidedLiftDrag = 2, /**Vertex normals are flipped to match velocity and lift and drag forces are applied */ + V_OneSided = 3, /**Vertex normals are taken as it is */ + F_TwoSided = 4, /**Face normals are flipped to match velocity */ + F_TwoSidedLiftDrag = 5, /**Face normals are flipped to match velocity and lift and drag forces are applied */ + F_OneSided = 6, /**Face normals are taken as it is */ + END = 7; + } + + /**eVSolver : velocities solvers */ + public static class eVSolver extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public eVSolver() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public eVSolver(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public eVSolver(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public eVSolver position(long position) { + return (eVSolver)super.position(position); + } + @Override public eVSolver getPointer(long i) { + return new eVSolver((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::eVSolver::_ */ + public static final int + Linear = 0, /**Linear solver */ + END = 1; + } + + /**ePSolver : positions solvers */ + public static class ePSolver extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public ePSolver() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public ePSolver(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ePSolver(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public ePSolver position(long position) { + return (ePSolver)super.position(position); + } + @Override public ePSolver getPointer(long i) { + return new ePSolver((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::ePSolver::_ */ + public static final int + Linear = 0, /**Linear solver */ + Anchors = 1, /**Anchor solver */ + RContacts = 2, /**Rigid contacts solver */ + SContacts = 3, /**Soft contacts solver */ + END = 4; + } + + /**eSolverPresets */ + public static class eSolverPresets extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public eSolverPresets() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public eSolverPresets(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public eSolverPresets(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public eSolverPresets position(long position) { + return (eSolverPresets)super.position(position); + } + @Override public eSolverPresets getPointer(long i) { + return new eSolverPresets((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::eSolverPresets::_ */ + public static final int + Positions = 0, + Velocities = 1, + Default = Positions, + END = Positions + 1; + } + + /**eFeature */ + public static class eFeature extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public eFeature() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public eFeature(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public eFeature(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public eFeature position(long position) { + return (eFeature)super.position(position); + } + @Override public eFeature getPointer(long i) { + return new eFeature((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::eFeature::_ */ + public static final int + None = 0, + Node = 1, + Link = 2, + Face = 3, + Tetra = 4, + END = 5; + } + + // + // Flags + // + + /**fCollision */ + public static class fCollision extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public fCollision() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public fCollision(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public fCollision(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public fCollision position(long position) { + return (fCollision)super.position(position); + } + @Override public fCollision getPointer(long i) { + return new fCollision((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::fCollision::_ */ + public static final int + RVSmask = 0x000f, /**Rigid versus soft mask */ + SDF_RS = 0x0001, /**SDF based rigid vs soft */ + CL_RS = 0x0002, /**Cluster vs convex rigid vs soft */ + SDF_RD = 0x0004, /**rigid vs deformable */ + + SVSmask = 0x00f0, /**Rigid versus soft mask */ + VF_SS = 0x0010, /**Vertex vs face soft vs soft handling */ + CL_SS = 0x0020, /**Cluster vs cluster soft vs soft handling */ + CL_SELF = 0x0040, /**Cluster soft body self collision */ + VF_DD = 0x0080, /**Vertex vs face soft vs soft handling */ + + RVDFmask = 0x0f00, /** Rigid versus deformable face mask */ + SDF_RDF = 0x0100, /** GJK based Rigid vs. deformable face */ + SDF_MDF = 0x0200, /** GJK based Multibody vs. deformable face */ + SDF_RDN = 0x0400, /** SDF based Rigid vs. deformable node */ + /* presets */ + Default = SDF_RS, + END = SDF_RS + 1; + } + + /**fMaterial */ + public static class fMaterial extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public fMaterial() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public fMaterial(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public fMaterial(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public fMaterial position(long position) { + return (fMaterial)super.position(position); + } + @Override public fMaterial getPointer(long i) { + return new fMaterial((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::fMaterial::_ */ + public static final int + DebugDraw = 0x0001, /** Enable debug draw */ + /* presets */ + Default = DebugDraw, + END = DebugDraw + 1; + } + + // + // API Types + // + + /* sRayCast */ + public static class sRayCast extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public sRayCast() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sRayCast(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sRayCast(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public sRayCast position(long position) { + return (sRayCast)super.position(position); + } + @Override public sRayCast getPointer(long i) { + return new sRayCast((Pointer)this).offsetAddress(i); + } + + public native btSoftBody body(); public native sRayCast body(btSoftBody setter); /** soft body */ + public native @Cast("btSoftBody::eFeature::_") int feature(); public native sRayCast feature(int setter); /** feature type */ + public native int index(); public native sRayCast index(int setter); /** feature index */ + public native @Cast("btScalar") float fraction(); public native sRayCast fraction(float setter); /** time of impact fraction (rayorg+(rayto-rayfrom)*fraction) */ + } + + /* ImplicitFn */ + public static class ImplicitFn extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ImplicitFn(Pointer p) { super(p); } + + public native @Cast("btScalar") float Eval(@Const @ByRef btVector3 x); + } + + // + // Internal types + // + + /* sCti is Softbody contact info */ + @NoOffset public static class sCti extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sCti(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sCti(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public sCti position(long position) { + return (sCti)super.position(position); + } + @Override public sCti getPointer(long i) { + return new sCti((Pointer)this).offsetAddress(i); + } + + public native @Const btCollisionObject m_colObj(); public native sCti m_colObj(btCollisionObject setter); /* Rigid body */ + public native @ByRef btVector3 m_normal(); public native sCti m_normal(btVector3 setter); /* Outward normal */ + public native @ByRef btVector3 m_impulse(); public native sCti m_impulse(btVector3 setter); /* Applied impulse */ + public native @Cast("btScalar") float m_offset(); public native sCti m_offset(float setter); /* Offset from origin */ + public native @ByRef btVector3 m_bary(); public native sCti m_bary(btVector3 setter); /* Barycentric weights for faces */ + public sCti() { super((Pointer)null); allocate(); } + private native void allocate(); + } + + /* sMedium */ + public static class sMedium extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public sMedium() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sMedium(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sMedium(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public sMedium position(long position) { + return (sMedium)super.position(position); + } + @Override public sMedium getPointer(long i) { + return new sMedium((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_velocity(); public native sMedium m_velocity(btVector3 setter); /* Velocity */ + public native @Cast("btScalar") float m_pressure(); public native sMedium m_pressure(float setter); /* Pressure */ + public native @Cast("btScalar") float m_density(); public native sMedium m_density(float setter); /* Density */ + } + + /* Base type */ + @NoOffset public static class Element extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Element(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Element(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Element position(long position) { + return (Element)super.position(position); + } + @Override public Element getPointer(long i) { + return new Element((Pointer)this).offsetAddress(i); + } + + public native Pointer m_tag(); public native Element m_tag(Pointer setter); // User data + public Element() { super((Pointer)null); allocate(); } + private native void allocate(); + } + /* Material */ + @NoOffset public static class Material extends Element { + static { Loader.load(); } + /** Default native constructor. */ + public Material() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Material(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Material(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Material position(long position) { + return (Material)super.position(position); + } + @Override public Material getPointer(long i) { + return new Material((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_kLST(); public native Material m_kLST(float setter); // Linear stiffness coefficient [0,1] + public native @Cast("btScalar") float m_kAST(); public native Material m_kAST(float setter); // Area/Angular stiffness coefficient [0,1] + public native @Cast("btScalar") float m_kVST(); public native Material m_kVST(float setter); // Volume stiffness coefficient [0,1] + public native int m_flags(); public native Material m_flags(int setter); // Flags + } + + /* Feature */ + @NoOffset public static class Feature extends Element { + static { Loader.load(); } + /** Default native constructor. */ + public Feature() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Feature(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Feature(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Feature position(long position) { + return (Feature)super.position(position); + } + @Override public Feature getPointer(long i) { + return new Feature((Pointer)this).offsetAddress(i); + } + + public native Material m_material(); public native Feature m_material(Material setter); // Material + } + /* Node */ + public static class RenderNode extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public RenderNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public RenderNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RenderNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public RenderNode position(long position) { + return (RenderNode)super.position(position); + } + @Override public RenderNode getPointer(long i) { + return new RenderNode((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_x(); public native RenderNode m_x(btVector3 setter); + public native @ByRef btVector3 m_uv1(); public native RenderNode m_uv1(btVector3 setter); + public native @ByRef btVector3 m_normal(); public native RenderNode m_normal(btVector3 setter); + } + @NoOffset public static class Node extends Feature { + static { Loader.load(); } + /** Default native constructor. */ + public Node() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Node(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Node(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Node position(long position) { + return (Node)super.position(position); + } + @Override public Node getPointer(long i) { + return new Node((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_x(); public native Node m_x(btVector3 setter); // Position + public native @ByRef btVector3 m_q(); public native Node m_q(btVector3 setter); // Previous step position/Test position + public native @ByRef btVector3 m_v(); public native Node m_v(btVector3 setter); // Velocity + public native @ByRef btVector3 m_vn(); public native Node m_vn(btVector3 setter); // Previous step velocity + public native @ByRef btVector3 m_f(); public native Node m_f(btVector3 setter); // Force accumulator + public native @ByRef btVector3 m_n(); public native Node m_n(btVector3 setter); // Normal + public native @Cast("btScalar") float m_im(); public native Node m_im(float setter); // 1/mass + public native @Cast("btScalar") float m_area(); public native Node m_area(float setter); // Area + // Leaf data + public native int m_constrained(); public native Node m_constrained(int setter); // depth of penetration + public native @NoOffset int m_battach(); public native Node m_battach(int setter); // Attached + public native int index(); public native Node index(int setter); + public native @ByRef btVector3 m_splitv(); public native Node m_splitv(btVector3 setter); // velocity associated with split impulse + public native @ByRef btMatrix3x3 m_effectiveMass(); public native Node m_effectiveMass(btMatrix3x3 setter); // effective mass in contact + public native @ByRef btMatrix3x3 m_effectiveMass_inv(); public native Node m_effectiveMass_inv(btMatrix3x3 setter); // inverse of effective mass + } + /* Link */ + @NoOffset public static class Link extends Feature { + static { Loader.load(); } + /** Default native constructor. */ + public Link() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Link(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Link(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Link position(long position) { + return (Link)super.position(position); + } + @Override public Link getPointer(long i) { + return new Link((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_c3(); public native Link m_c3(btVector3 setter); // gradient + public native Node m_n(int i); public native Link m_n(int i, Node setter); + @MemberGetter public native @Cast("btSoftBody::Node**") PointerPointer m_n(); // Node pointers + public native @Cast("btScalar") float m_rl(); public native Link m_rl(float setter); // Rest length + public native @NoOffset int m_bbending(); public native Link m_bbending(int setter); // Bending link + public native @Cast("btScalar") float m_c0(); public native Link m_c0(float setter); // (ima+imb)*kLST + public native @Cast("btScalar") float m_c1(); public native Link m_c1(float setter); // rl^2 + public native @Cast("btScalar") float m_c2(); public native Link m_c2(float setter); // |gradient|^2/c0 + } + public static class RenderFace extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public RenderFace() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public RenderFace(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RenderFace(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public RenderFace position(long position) { + return (RenderFace)super.position(position); + } + @Override public RenderFace getPointer(long i) { + return new RenderFace((Pointer)this).offsetAddress(i); + } + + public native RenderNode m_n(int i); public native RenderFace m_n(int i, RenderNode setter); + @MemberGetter public native @Cast("btSoftBody::RenderNode**") PointerPointer m_n(); // Node pointers + } + + /* Face */ + @NoOffset public static class Face extends Feature { + static { Loader.load(); } + /** Default native constructor. */ + public Face() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Face(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Face(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Face position(long position) { + return (Face)super.position(position); + } + @Override public Face getPointer(long i) { + return new Face((Pointer)this).offsetAddress(i); + } + + public native Node m_n(int i); public native Face m_n(int i, Node setter); + @MemberGetter public native @Cast("btSoftBody::Node**") PointerPointer m_n(); // Node pointers + public native @ByRef btVector3 m_normal(); public native Face m_normal(btVector3 setter); // Normal + public native @Cast("btScalar") float m_ra(); public native Face m_ra(float setter); // Rest area + // Leaf data + public native @ByRef btVector4 m_pcontact(); public native Face m_pcontact(btVector4 setter); // barycentric weights of the persistent contact + public native @ByRef btVector3 m_n0(); public native Face m_n0(btVector3 setter); + public native @ByRef btVector3 m_n1(); public native Face m_n1(btVector3 setter); + public native @ByRef btVector3 m_vn(); public native Face m_vn(btVector3 setter); + public native int m_index(); public native Face m_index(int setter); + } + /* Tetra */ + @NoOffset public static class Tetra extends Feature { + static { Loader.load(); } + /** Default native constructor. */ + public Tetra() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Tetra(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Tetra(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Tetra position(long position) { + return (Tetra)super.position(position); + } + @Override public Tetra getPointer(long i) { + return new Tetra((Pointer)this).offsetAddress(i); + } + + public native Node m_n(int i); public native Tetra m_n(int i, Node setter); + @MemberGetter public native @Cast("btSoftBody::Node**") PointerPointer m_n(); // Node pointers + public native @Cast("btScalar") float m_rv(); public native Tetra m_rv(float setter); // Rest volume + // Leaf data + public native @ByRef btVector3 m_c0(int i); public native Tetra m_c0(int i, btVector3 setter); + @MemberGetter public native btVector3 m_c0(); // gradients + public native @Cast("btScalar") float m_c1(); public native Tetra m_c1(float setter); // (4*kVST)/(im0+im1+im2+im3) + public native @Cast("btScalar") float m_c2(); public native Tetra m_c2(float setter); // m_c1/sum(|g0..3|^2) + public native @ByRef btMatrix3x3 m_Dm_inverse(); public native Tetra m_Dm_inverse(btMatrix3x3 setter); // rest Dm^-1 + public native @ByRef btMatrix3x3 m_F(); public native Tetra m_F(btMatrix3x3 setter); + public native @Cast("btScalar") float m_element_measure(); public native Tetra m_element_measure(float setter); + public native @ByRef btVector4 m_P_inv(int i); public native Tetra m_P_inv(int i, btVector4 setter); + @MemberGetter public native btVector4 m_P_inv(); // first three columns of P_inv matrix + } + + /* TetraScratch */ + public static class TetraScratch extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public TetraScratch() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public TetraScratch(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public TetraScratch(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public TetraScratch position(long position) { + return (TetraScratch)super.position(position); + } + @Override public TetraScratch getPointer(long i) { + return new TetraScratch((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3 m_F(); public native TetraScratch m_F(btMatrix3x3 setter); // deformation gradient F + public native @Cast("btScalar") float m_trace(); public native TetraScratch m_trace(float setter); // trace of F^T * F + public native @Cast("btScalar") float m_J(); public native TetraScratch m_J(float setter); // det(F) + public native @ByRef btMatrix3x3 m_cofF(); public native TetraScratch m_cofF(btMatrix3x3 setter); // cofactor of F + public native @ByRef btMatrix3x3 m_corotation(); public native TetraScratch m_corotation(btMatrix3x3 setter); // corotatio of the tetra + } + + /* RContact */ + public static class RContact extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public RContact() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public RContact(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RContact(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public RContact position(long position) { + return (RContact)super.position(position); + } + @Override public RContact getPointer(long i) { + return new RContact((Pointer)this).offsetAddress(i); + } + + public native @ByRef sCti m_cti(); public native RContact m_cti(sCti setter); // Contact infos + public native Node m_node(); public native RContact m_node(Node setter); // Owner node + public native @ByRef btMatrix3x3 m_c0(); public native RContact m_c0(btMatrix3x3 setter); // Impulse matrix + public native @ByRef btVector3 m_c1(); public native RContact m_c1(btVector3 setter); // Relative anchor + public native @Cast("btScalar") float m_c2(); public native RContact m_c2(float setter); // ima*dt + public native @Cast("btScalar") float m_c3(); public native RContact m_c3(float setter); // Friction + public native @Cast("btScalar") float m_c4(); public native RContact m_c4(float setter); // Hardness + + // jacobians and unit impulse responses for multibody + public native @ByRef btMultiBodyJacobianData jacobianData_normal(); public native RContact jacobianData_normal(btMultiBodyJacobianData setter); + public native @ByRef btMultiBodyJacobianData jacobianData_t1(); public native RContact jacobianData_t1(btMultiBodyJacobianData setter); + public native @ByRef btMultiBodyJacobianData jacobianData_t2(); public native RContact jacobianData_t2(btMultiBodyJacobianData setter); + public native @ByRef btVector3 t1(); public native RContact t1(btVector3 setter); + public native @ByRef btVector3 t2(); public native RContact t2(btVector3 setter); + } + + public static class DeformableRigidContact extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public DeformableRigidContact() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DeformableRigidContact(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DeformableRigidContact(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public DeformableRigidContact position(long position) { + return (DeformableRigidContact)super.position(position); + } + @Override public DeformableRigidContact getPointer(long i) { + return new DeformableRigidContact((Pointer)this).offsetAddress(i); + } + + public native @ByRef sCti m_cti(); public native DeformableRigidContact m_cti(sCti setter); // Contact infos + public native @ByRef btMatrix3x3 m_c0(); public native DeformableRigidContact m_c0(btMatrix3x3 setter); // Impulse matrix + public native @ByRef btVector3 m_c1(); public native DeformableRigidContact m_c1(btVector3 setter); // Relative anchor + public native @Cast("btScalar") float m_c2(); public native DeformableRigidContact m_c2(float setter); // inverse mass of node/face + public native @Cast("btScalar") float m_c3(); public native DeformableRigidContact m_c3(float setter); // Friction + public native @Cast("btScalar") float m_c4(); public native DeformableRigidContact m_c4(float setter); // Hardness + public native @ByRef btMatrix3x3 m_c5(); public native DeformableRigidContact m_c5(btMatrix3x3 setter); // inverse effective mass + + // jacobians and unit impulse responses for multibody + public native @ByRef btMultiBodyJacobianData jacobianData_normal(); public native DeformableRigidContact jacobianData_normal(btMultiBodyJacobianData setter); + public native @ByRef btMultiBodyJacobianData jacobianData_t1(); public native DeformableRigidContact jacobianData_t1(btMultiBodyJacobianData setter); + public native @ByRef btMultiBodyJacobianData jacobianData_t2(); public native DeformableRigidContact jacobianData_t2(btMultiBodyJacobianData setter); + public native @ByRef btVector3 t1(); public native DeformableRigidContact t1(btVector3 setter); + public native @ByRef btVector3 t2(); public native DeformableRigidContact t2(btVector3 setter); + } + + @NoOffset public static class DeformableNodeRigidContact extends DeformableRigidContact { + static { Loader.load(); } + /** Default native constructor. */ + public DeformableNodeRigidContact() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DeformableNodeRigidContact(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DeformableNodeRigidContact(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public DeformableNodeRigidContact position(long position) { + return (DeformableNodeRigidContact)super.position(position); + } + @Override public DeformableNodeRigidContact getPointer(long i) { + return new DeformableNodeRigidContact((Pointer)this).offsetAddress(i); + } + + public native Node m_node(); public native DeformableNodeRigidContact m_node(Node setter); // Owner node + } + + @NoOffset public static class DeformableNodeRigidAnchor extends DeformableNodeRigidContact { + static { Loader.load(); } + /** Default native constructor. */ + public DeformableNodeRigidAnchor() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DeformableNodeRigidAnchor(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DeformableNodeRigidAnchor(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public DeformableNodeRigidAnchor position(long position) { + return (DeformableNodeRigidAnchor)super.position(position); + } + @Override public DeformableNodeRigidAnchor getPointer(long i) { + return new DeformableNodeRigidAnchor((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_local(); public native DeformableNodeRigidAnchor m_local(btVector3 setter); // Anchor position in body space + } + + @NoOffset public static class DeformableFaceRigidContact extends DeformableRigidContact { + static { Loader.load(); } + /** Default native constructor. */ + public DeformableFaceRigidContact() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DeformableFaceRigidContact(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DeformableFaceRigidContact(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public DeformableFaceRigidContact position(long position) { + return (DeformableFaceRigidContact)super.position(position); + } + @Override public DeformableFaceRigidContact getPointer(long i) { + return new DeformableFaceRigidContact((Pointer)this).offsetAddress(i); + } + + public native Face m_face(); public native DeformableFaceRigidContact m_face(Face setter); // Owner face + public native @ByRef btVector3 m_contactPoint(); public native DeformableFaceRigidContact m_contactPoint(btVector3 setter); // Contact point + public native @ByRef btVector3 m_bary(); public native DeformableFaceRigidContact m_bary(btVector3 setter); // Barycentric weights + public native @ByRef btVector3 m_weights(); public native DeformableFaceRigidContact m_weights(btVector3 setter); // v_contactPoint * m_weights[i] = m_face->m_node[i]->m_v; + } + + public static class DeformableFaceNodeContact extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public DeformableFaceNodeContact() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DeformableFaceNodeContact(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DeformableFaceNodeContact(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public DeformableFaceNodeContact position(long position) { + return (DeformableFaceNodeContact)super.position(position); + } + @Override public DeformableFaceNodeContact getPointer(long i) { + return new DeformableFaceNodeContact((Pointer)this).offsetAddress(i); + } + + public native Node m_node(); public native DeformableFaceNodeContact m_node(Node setter); // Node + public native Face m_face(); public native DeformableFaceNodeContact m_face(Face setter); // Face + public native @ByRef btVector3 m_bary(); public native DeformableFaceNodeContact m_bary(btVector3 setter); // Barycentric weights + public native @ByRef btVector3 m_weights(); public native DeformableFaceNodeContact m_weights(btVector3 setter); // v_contactPoint * m_weights[i] = m_face->m_node[i]->m_v; + public native @ByRef btVector3 m_normal(); public native DeformableFaceNodeContact m_normal(btVector3 setter); // Normal + public native @Cast("btScalar") float m_margin(); public native DeformableFaceNodeContact m_margin(float setter); // Margin + public native @Cast("btScalar") float m_friction(); public native DeformableFaceNodeContact m_friction(float setter); // Friction + public native @Cast("btScalar") float m_imf(); public native DeformableFaceNodeContact m_imf(float setter); // inverse mass of the face at contact point + public native @Cast("btScalar") float m_c0(); public native DeformableFaceNodeContact m_c0(float setter); // scale of the impulse matrix; + } + + /* SContact */ + public static class SContact extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SContact() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SContact(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SContact(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SContact position(long position) { + return (SContact)super.position(position); + } + @Override public SContact getPointer(long i) { + return new SContact((Pointer)this).offsetAddress(i); + } + + public native Node m_node(); public native SContact m_node(Node setter); // Node + public native Face m_face(); public native SContact m_face(Face setter); // Face + public native @ByRef btVector3 m_weights(); public native SContact m_weights(btVector3 setter); // Weigths + public native @ByRef btVector3 m_normal(); public native SContact m_normal(btVector3 setter); // Normal + public native @Cast("btScalar") float m_margin(); public native SContact m_margin(float setter); // Margin + public native @Cast("btScalar") float m_friction(); public native SContact m_friction(float setter); // Friction + public native @Cast("btScalar") float m_cfm(int i); public native SContact m_cfm(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_cfm(); // Constraint force mixing + } + /* Anchor */ + public static class Anchor extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public Anchor() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Anchor(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Anchor(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Anchor position(long position) { + return (Anchor)super.position(position); + } + @Override public Anchor getPointer(long i) { + return new Anchor((Pointer)this).offsetAddress(i); + } + + public native Node m_node(); public native Anchor m_node(Node setter); // Node pointer + public native @ByRef btVector3 m_local(); public native Anchor m_local(btVector3 setter); // Anchor position in body space + public native btRigidBody m_body(); public native Anchor m_body(btRigidBody setter); // Body + public native @Cast("btScalar") float m_influence(); public native Anchor m_influence(float setter); + public native @ByRef btMatrix3x3 m_c0(); public native Anchor m_c0(btMatrix3x3 setter); // Impulse matrix + public native @ByRef btVector3 m_c1(); public native Anchor m_c1(btVector3 setter); // Relative anchor + public native @Cast("btScalar") float m_c2(); public native Anchor m_c2(float setter); // ima*dt + } + /* Note */ + @NoOffset public static class Note extends Element { + static { Loader.load(); } + /** Default native constructor. */ + public Note() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Note(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Note(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Note position(long position) { + return (Note)super.position(position); + } + @Override public Note getPointer(long i) { + return new Note((Pointer)this).offsetAddress(i); + } + + public native @Cast("const char*") BytePointer m_text(); public native Note m_text(BytePointer setter); // Text + public native @ByRef btVector3 m_offset(); public native Note m_offset(btVector3 setter); // Offset + public native int m_rank(); public native Note m_rank(int setter); // Rank + public native Node m_nodes(int i); public native Note m_nodes(int i, Node setter); + @MemberGetter public native @Cast("btSoftBody::Node**") PointerPointer m_nodes(); // Nodes + public native @Cast("btScalar") float m_coords(int i); public native Note m_coords(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_coords(); // Coordinates + } + /* Pose */ + public static class Pose extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public Pose() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Pose(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Pose(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Pose position(long position) { + return (Pose)super.position(position); + } + @Override public Pose getPointer(long i) { + return new Pose((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") boolean m_bvolume(); public native Pose m_bvolume(boolean setter); // Is valid + public native @Cast("bool") boolean m_bframe(); public native Pose m_bframe(boolean setter); // Is frame + public native @Cast("btScalar") float m_volume(); public native Pose m_volume(float setter); // Rest volume + public native @ByRef @Cast("btSoftBody::tVector3Array*") btAlignedObjectArray_btVector3 m_pos(); public native Pose m_pos(btAlignedObjectArray_btVector3 setter); // Reference positions + public native @ByRef @Cast("btSoftBody::tScalarArray*") btAlignedObjectArray_btScalar m_wgh(); public native Pose m_wgh(btAlignedObjectArray_btScalar setter); // Weights + public native @ByRef btVector3 m_com(); public native Pose m_com(btVector3 setter); // COM + public native @ByRef btMatrix3x3 m_rot(); public native Pose m_rot(btMatrix3x3 setter); // Rotation + public native @ByRef btMatrix3x3 m_scl(); public native Pose m_scl(btMatrix3x3 setter); // Scale + public native @ByRef btMatrix3x3 m_aqq(); public native Pose m_aqq(btMatrix3x3 setter); // Base scaling + } + /* Cluster */ + @NoOffset public static class Cluster extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Cluster(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Cluster(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Cluster position(long position) { + return (Cluster)super.position(position); + } + @Override public Cluster getPointer(long i) { + return new Cluster((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Cast("btSoftBody::tScalarArray*") btAlignedObjectArray_btScalar m_masses(); public native Cluster m_masses(btAlignedObjectArray_btScalar setter); + + public native @ByRef @Cast("btSoftBody::tVector3Array*") btAlignedObjectArray_btVector3 m_framerefs(); public native Cluster m_framerefs(btAlignedObjectArray_btVector3 setter); + public native @ByRef btTransform m_framexform(); public native Cluster m_framexform(btTransform setter); + public native @Cast("btScalar") float m_idmass(); public native Cluster m_idmass(float setter); + public native @Cast("btScalar") float m_imass(); public native Cluster m_imass(float setter); + public native @ByRef btMatrix3x3 m_locii(); public native Cluster m_locii(btMatrix3x3 setter); + public native @ByRef btMatrix3x3 m_invwi(); public native Cluster m_invwi(btMatrix3x3 setter); + public native @ByRef btVector3 m_com(); public native Cluster m_com(btVector3 setter); + public native @ByRef btVector3 m_vimpulses(int i); public native Cluster m_vimpulses(int i, btVector3 setter); + @MemberGetter public native btVector3 m_vimpulses(); + public native @ByRef btVector3 m_dimpulses(int i); public native Cluster m_dimpulses(int i, btVector3 setter); + @MemberGetter public native btVector3 m_dimpulses(); + public native int m_nvimpulses(); public native Cluster m_nvimpulses(int setter); + public native int m_ndimpulses(); public native Cluster m_ndimpulses(int setter); + public native @ByRef btVector3 m_lv(); public native Cluster m_lv(btVector3 setter); + public native @ByRef btVector3 m_av(); public native Cluster m_av(btVector3 setter); + + public native @Cast("btScalar") float m_ndamping(); public native Cluster m_ndamping(float setter); /* Node damping */ + public native @Cast("btScalar") float m_ldamping(); public native Cluster m_ldamping(float setter); /* Linear damping */ + public native @Cast("btScalar") float m_adamping(); public native Cluster m_adamping(float setter); /* Angular damping */ + public native @Cast("btScalar") float m_matching(); public native Cluster m_matching(float setter); + public native @Cast("btScalar") float m_maxSelfCollisionImpulse(); public native Cluster m_maxSelfCollisionImpulse(float setter); + public native @Cast("btScalar") float m_selfCollisionImpulseFactor(); public native Cluster m_selfCollisionImpulseFactor(float setter); + public native @Cast("bool") boolean m_containsAnchor(); public native Cluster m_containsAnchor(boolean setter); + public native @Cast("bool") boolean m_collide(); public native Cluster m_collide(boolean setter); + public native int m_clusterIndex(); public native Cluster m_clusterIndex(int setter); + public Cluster() { super((Pointer)null); allocate(); } + private native void allocate(); + } + /* Impulse */ + @NoOffset public static class Impulse extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Impulse(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Impulse(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Impulse position(long position) { + return (Impulse)super.position(position); + } + @Override public Impulse getPointer(long i) { + return new Impulse((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_velocity(); public native Impulse m_velocity(btVector3 setter); + public native @ByRef btVector3 m_drift(); public native Impulse m_drift(btVector3 setter); + public native @NoOffset int m_asVelocity(); public native Impulse m_asVelocity(int setter); + public native @NoOffset int m_asDrift(); public native Impulse m_asDrift(int setter); + public Impulse() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @ByVal @Name("operator -") Impulse subtract(); + public native @ByVal @Name("operator *") Impulse multiply(@Cast("btScalar") float x); + } + /* Body */ + @NoOffset public static class Body extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Body(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Body(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Body position(long position) { + return (Body)super.position(position); + } + @Override public Body getPointer(long i) { + return new Body((Pointer)this).offsetAddress(i); + } + + public native Cluster m_soft(); public native Body m_soft(Cluster setter); + public native btRigidBody m_rigid(); public native Body m_rigid(btRigidBody setter); + public native @Const btCollisionObject m_collisionObject(); public native Body m_collisionObject(btCollisionObject setter); + + public Body() { super((Pointer)null); allocate(); } + private native void allocate(); + public Body(Cluster p) { super((Pointer)null); allocate(p); } + private native void allocate(Cluster p); + public Body(@Const btCollisionObject colObj) { super((Pointer)null); allocate(colObj); } + private native void allocate(@Const btCollisionObject colObj); + + public native void activate(); + public native @Const @ByRef btMatrix3x3 invWorldInertia(); + public native @Cast("btScalar") float invMass(); + public native @Const @ByRef btTransform xform(); + public native @ByVal btVector3 linearVelocity(); + public native @ByVal btVector3 angularVelocity(@Const @ByRef btVector3 rpos); + public native @ByVal btVector3 angularVelocity(); + public native @ByVal btVector3 velocity(@Const @ByRef btVector3 rpos); + public native void applyVImpulse(@Const @ByRef btVector3 impulse, @Const @ByRef btVector3 rpos); + public native void applyDImpulse(@Const @ByRef btVector3 impulse, @Const @ByRef btVector3 rpos); + public native void applyImpulse(@Const @ByRef Impulse impulse, @Const @ByRef btVector3 rpos); + public native void applyVAImpulse(@Const @ByRef btVector3 impulse); + public native void applyDAImpulse(@Const @ByRef btVector3 impulse); + public native void applyAImpulse(@Const @ByRef Impulse impulse); + public native void applyDCImpulse(@Const @ByRef btVector3 impulse); + } + /* Joint */ + @NoOffset public static class Joint extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Joint(Pointer p) { super(p); } + + @NoOffset public static class Specs extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Specs(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Specs(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Specs position(long position) { + return (Specs)super.position(position); + } + @Override public Specs getPointer(long i) { + return new Specs((Pointer)this).offsetAddress(i); + } + + public Specs() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float erp(); public native Specs erp(float setter); + public native @Cast("btScalar") float cfm(); public native Specs cfm(float setter); + public native @Cast("btScalar") float split(); public native Specs split(float setter); + } + public native @ByRef Body m_bodies(int i); public native Joint m_bodies(int i, Body setter); + @MemberGetter public native Body m_bodies(); + public native @ByRef btVector3 m_refs(int i); public native Joint m_refs(int i, btVector3 setter); + @MemberGetter public native btVector3 m_refs(); + public native @Cast("btScalar") float m_cfm(); public native Joint m_cfm(float setter); + public native @Cast("btScalar") float m_erp(); public native Joint m_erp(float setter); + public native @Cast("btScalar") float m_split(); public native Joint m_split(float setter); + public native @ByRef btVector3 m_drift(); public native Joint m_drift(btVector3 setter); + public native @ByRef btVector3 m_sdrift(); public native Joint m_sdrift(btVector3 setter); + public native @ByRef btMatrix3x3 m_massmatrix(); public native Joint m_massmatrix(btMatrix3x3 setter); + public native @Cast("bool") boolean m_delete(); public native Joint m_delete(boolean setter); + public native void Prepare(@Cast("btScalar") float dt, int iterations); + public native void Solve(@Cast("btScalar") float dt, @Cast("btScalar") float sor); + public native void Terminate(@Cast("btScalar") float dt); + } + /* LJoint */ + @NoOffset public static class LJoint extends Joint { + static { Loader.load(); } + /** Default native constructor. */ + public LJoint() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public LJoint(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LJoint(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public LJoint position(long position) { + return (LJoint)super.position(position); + } + @Override public LJoint getPointer(long i) { + return new LJoint((Pointer)this).offsetAddress(i); + } + + @NoOffset public static class Specs extends Joint.Specs { + static { Loader.load(); } + /** Default native constructor. */ + public Specs() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Specs(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Specs(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Specs position(long position) { + return (Specs)super.position(position); + } + @Override public Specs getPointer(long i) { + return new Specs((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("position") btVector3 _position(); public native Specs _position(btVector3 setter); + } + public native @ByRef btVector3 m_rpos(int i); public native LJoint m_rpos(int i, btVector3 setter); + @MemberGetter public native btVector3 m_rpos(); + public native void Prepare(@Cast("btScalar") float dt, int iterations); + public native void Solve(@Cast("btScalar") float dt, @Cast("btScalar") float sor); + public native void Terminate(@Cast("btScalar") float dt); + + } + /* AJoint */ + @NoOffset public static class AJoint extends Joint { + static { Loader.load(); } + /** Default native constructor. */ + public AJoint() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public AJoint(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public AJoint(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public AJoint position(long position) { + return (AJoint)super.position(position); + } + @Override public AJoint getPointer(long i) { + return new AJoint((Pointer)this).offsetAddress(i); + } + + public static class IControl extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public IControl() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public IControl(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IControl(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public IControl position(long position) { + return (IControl)super.position(position); + } + @Override public IControl getPointer(long i) { + return new IControl((Pointer)this).offsetAddress(i); + } + + public native void Prepare(AJoint arg0); + public native @Cast("btScalar") float Speed(AJoint arg0, @Cast("btScalar") float current); + public static native IControl Default(); + } + @NoOffset public static class Specs extends Joint.Specs { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Specs(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Specs(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Specs position(long position) { + return (Specs)super.position(position); + } + @Override public Specs getPointer(long i) { + return new Specs((Pointer)this).offsetAddress(i); + } + + public Specs() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @ByRef btVector3 axis(); public native Specs axis(btVector3 setter); + public native IControl icontrol(); public native Specs icontrol(IControl setter); + } + public native @ByRef btVector3 m_axis(int i); public native AJoint m_axis(int i, btVector3 setter); + @MemberGetter public native btVector3 m_axis(); + public native IControl m_icontrol(); public native AJoint m_icontrol(IControl setter); + public native void Prepare(@Cast("btScalar") float dt, int iterations); + public native void Solve(@Cast("btScalar") float dt, @Cast("btScalar") float sor); + public native void Terminate(@Cast("btScalar") float dt); + + } + /* CJoint */ + @NoOffset public static class CJoint extends Joint { + static { Loader.load(); } + /** Default native constructor. */ + public CJoint() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CJoint(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CJoint(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CJoint position(long position) { + return (CJoint)super.position(position); + } + @Override public CJoint getPointer(long i) { + return new CJoint((Pointer)this).offsetAddress(i); + } + + public native int m_life(); public native CJoint m_life(int setter); + public native int m_maxlife(); public native CJoint m_maxlife(int setter); + public native @ByRef btVector3 m_rpos(int i); public native CJoint m_rpos(int i, btVector3 setter); + @MemberGetter public native btVector3 m_rpos(); + public native @ByRef btVector3 m_normal(); public native CJoint m_normal(btVector3 setter); + public native @Cast("btScalar") float m_friction(); public native CJoint m_friction(float setter); + public native void Prepare(@Cast("btScalar") float dt, int iterations); + public native void Solve(@Cast("btScalar") float dt, @Cast("btScalar") float sor); + public native void Terminate(@Cast("btScalar") float dt); + + } + /* Config */ + public static class Config extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public Config() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Config(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Config(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Config position(long position) { + return (Config)super.position(position); + } + @Override public Config getPointer(long i) { + return new Config((Pointer)this).offsetAddress(i); + } + + public native @Cast("btSoftBody::eAeroModel::_") int aeromodel(); public native Config aeromodel(int setter); // Aerodynamic model (default: V_Point) + public native @Cast("btScalar") float kVCF(); public native Config kVCF(float setter); // Velocities correction factor (Baumgarte) + public native @Cast("btScalar") float kDP(); public native Config kDP(float setter); // Damping coefficient [0,1] + public native @Cast("btScalar") float kDG(); public native Config kDG(float setter); // Drag coefficient [0,+inf] + public native @Cast("btScalar") float kLF(); public native Config kLF(float setter); // Lift coefficient [0,+inf] + public native @Cast("btScalar") float kPR(); public native Config kPR(float setter); // Pressure coefficient [-inf,+inf] + public native @Cast("btScalar") float kVC(); public native Config kVC(float setter); // Volume conversation coefficient [0,+inf] + public native @Cast("btScalar") float kDF(); public native Config kDF(float setter); // Dynamic friction coefficient [0,1] + public native @Cast("btScalar") float kMT(); public native Config kMT(float setter); // Pose matching coefficient [0,1] + public native @Cast("btScalar") float kCHR(); public native Config kCHR(float setter); // Rigid contacts hardness [0,1] + public native @Cast("btScalar") float kKHR(); public native Config kKHR(float setter); // Kinetic contacts hardness [0,1] + public native @Cast("btScalar") float kSHR(); public native Config kSHR(float setter); // Soft contacts hardness [0,1] + public native @Cast("btScalar") float kAHR(); public native Config kAHR(float setter); // Anchors hardness [0,1] + public native @Cast("btScalar") float kSRHR_CL(); public native Config kSRHR_CL(float setter); // Soft vs rigid hardness [0,1] (cluster only) + public native @Cast("btScalar") float kSKHR_CL(); public native Config kSKHR_CL(float setter); // Soft vs kinetic hardness [0,1] (cluster only) + public native @Cast("btScalar") float kSSHR_CL(); public native Config kSSHR_CL(float setter); // Soft vs soft hardness [0,1] (cluster only) + public native @Cast("btScalar") float kSR_SPLT_CL(); public native Config kSR_SPLT_CL(float setter); // Soft vs rigid impulse split [0,1] (cluster only) + public native @Cast("btScalar") float kSK_SPLT_CL(); public native Config kSK_SPLT_CL(float setter); // Soft vs rigid impulse split [0,1] (cluster only) + public native @Cast("btScalar") float kSS_SPLT_CL(); public native Config kSS_SPLT_CL(float setter); // Soft vs rigid impulse split [0,1] (cluster only) + public native @Cast("btScalar") float maxvolume(); public native Config maxvolume(float setter); // Maximum volume ratio for pose + public native @Cast("btScalar") float timescale(); public native Config timescale(float setter); // Time scale + public native int viterations(); public native Config viterations(int setter); // Velocities solver iterations + public native int piterations(); public native Config piterations(int setter); // Positions solver iterations + public native int diterations(); public native Config diterations(int setter); // Drift solver iterations + public native int citerations(); public native Config citerations(int setter); // Cluster solver iterations + public native int collisions(); public native Config collisions(int setter); // Collisions flags + public native @ByRef @Cast("btSoftBody::tVSolverArray*") btAlignedObjectArray_btSoftBody m_vsequence(); public native Config m_vsequence(btAlignedObjectArray_btSoftBody setter); // Velocity solvers sequence + public native @ByRef @Cast("btSoftBody::tPSolverArray*") btAlignedObjectArray_btSoftBody m_psequence(); public native Config m_psequence(btAlignedObjectArray_btSoftBody setter); // Position solvers sequence + public native @ByRef @Cast("btSoftBody::tPSolverArray*") btAlignedObjectArray_btSoftBody m_dsequence(); public native Config m_dsequence(btAlignedObjectArray_btSoftBody setter); // Drift solvers sequence + public native @Cast("btScalar") float drag(); public native Config drag(float setter); // deformable air drag + public native @Cast("btScalar") float m_maxStress(); public native Config m_maxStress(float setter); // Maximum principle first Piola stress + } + /* SolverState */ + @NoOffset public static class SolverState extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SolverState(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SolverState(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public SolverState position(long position) { + return (SolverState)super.position(position); + } + @Override public SolverState getPointer(long i) { + return new SolverState((Pointer)this).offsetAddress(i); + } + + //if you add new variables, always initialize them! + public SolverState() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float sdt(); public native SolverState sdt(float setter); // dt*timescale + public native @Cast("btScalar") float isdt(); public native SolverState isdt(float setter); // 1/sdt + public native @Cast("btScalar") float velmrg(); public native SolverState velmrg(float setter); // velocity margin + public native @Cast("btScalar") float radmrg(); public native SolverState radmrg(float setter); // radial margin + public native @Cast("btScalar") float updmrg(); public native SolverState updmrg(float setter); // Update margin + } + /** RayFromToCaster takes a ray from, ray to (instead of direction!) */ + + // + // Typedefs + // + + public static class psolver_t extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public psolver_t(Pointer p) { super(p); } + protected psolver_t() { allocate(); } + private native void allocate(); + public native void call(btSoftBody arg0, @Cast("btScalar") float arg1, @Cast("btScalar") float arg2); + } + public static class vsolver_t extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public vsolver_t(Pointer p) { super(p); } + protected vsolver_t() { allocate(); } + private native void allocate(); + public native void call(btSoftBody arg0, @Cast("btScalar") float arg1); + } + + // + // Fields + // + + public native @ByRef Config m_cfg(); public native btSoftBody m_cfg(Config setter); // Configuration + public native @ByRef SolverState m_sst(); public native btSoftBody m_sst(SolverState setter); // Solver state + public native @ByRef Pose m_pose(); public native btSoftBody m_pose(Pose setter); // Pose + public native Pointer m_tag(); public native btSoftBody m_tag(Pointer setter); // User data + public native btSoftBodyWorldInfo m_worldInfo(); public native btSoftBody m_worldInfo(btSoftBodyWorldInfo setter); // World info + public native @ByRef @Cast("btSoftBody::tNoteArray*") btAlignedObjectArray_btSoftBody m_notes(); public native btSoftBody m_notes(btAlignedObjectArray_btSoftBody setter); // Notes + public native @ByRef @Cast("btSoftBody::tNodeArray*") btAlignedObjectArray_btSoftBody m_nodes(); public native btSoftBody m_nodes(btAlignedObjectArray_btSoftBody setter); // Nodes + public native @ByRef @Cast("btSoftBody::tRenderNodeArray*") btAlignedObjectArray_btSoftBody m_renderNodes(); public native btSoftBody m_renderNodes(btAlignedObjectArray_btSoftBody setter); // Render Nodes + public native @ByRef @Cast("btSoftBody::tLinkArray*") btAlignedObjectArray_btSoftBody m_links(); public native btSoftBody m_links(btAlignedObjectArray_btSoftBody setter); // Links + public native @ByRef @Cast("btSoftBody::tFaceArray*") btAlignedObjectArray_btSoftBody m_faces(); public native btSoftBody m_faces(btAlignedObjectArray_btSoftBody setter); // Faces + public native @ByRef @Cast("btSoftBody::tRenderFaceArray*") btAlignedObjectArray_btSoftBody m_renderFaces(); public native btSoftBody m_renderFaces(btAlignedObjectArray_btSoftBody setter); // Faces + public native @ByRef @Cast("btSoftBody::tTetraArray*") btAlignedObjectArray_btSoftBody m_tetras(); public native btSoftBody m_tetras(btAlignedObjectArray_btSoftBody setter); // Tetras + + + public native @ByRef @Cast("btSoftBody::tAnchorArray*") btAlignedObjectArray_btSoftBody m_anchors(); public native btSoftBody m_anchors(btAlignedObjectArray_btSoftBody setter); // Anchors + + public native @ByRef @Cast("btSoftBody::tRContactArray*") btAlignedObjectArray_btSoftBody m_rcontacts(); public native btSoftBody m_rcontacts(btAlignedObjectArray_btSoftBody setter); // Rigid contacts + + + + public native @ByRef @Cast("btSoftBody::tSContactArray*") btAlignedObjectArray_btSoftBody m_scontacts(); public native btSoftBody m_scontacts(btAlignedObjectArray_btSoftBody setter); // Soft contacts + public native @ByRef @Cast("btSoftBody::tJointArray*") btAlignedObjectArray_btSoftBody m_joints(); public native btSoftBody m_joints(btAlignedObjectArray_btSoftBody setter); // Joints + public native @ByRef @Cast("btSoftBody::tMaterialArray*") btAlignedObjectArray_btSoftBody m_materials(); public native btSoftBody m_materials(btAlignedObjectArray_btSoftBody setter); // Materials + public native @Cast("btScalar") float m_timeacc(); public native btSoftBody m_timeacc(float setter); // Time accumulator + public native @ByRef btVector3 m_bounds(int i); public native btSoftBody m_bounds(int i, btVector3 setter); + @MemberGetter public native btVector3 m_bounds(); // Spatial bounds + public native @Cast("bool") boolean m_bUpdateRtCst(); public native btSoftBody m_bUpdateRtCst(boolean setter); // Update runtime constants + public native @ByRef btDbvt m_ndbvt(); public native btSoftBody m_ndbvt(btDbvt setter); // Nodes tree + public native @ByRef btDbvt m_fdbvt(); public native btSoftBody m_fdbvt(btDbvt setter); // Faces tree + // Faces tree with normals + public native @ByRef btDbvt m_cdbvt(); public native btSoftBody m_cdbvt(btDbvt setter); // Clusters tree + public native @ByRef @Cast("btSoftBody::tClusterArray*") btAlignedObjectArray_btSoftBody m_clusters(); public native btSoftBody m_clusters(btAlignedObjectArray_btSoftBody setter); // Clusters + public native @Cast("btScalar") float m_dampingCoefficient(); public native btSoftBody m_dampingCoefficient(float setter); // Damping Coefficient + public native @Cast("btScalar") float m_sleepingThreshold(); public native btSoftBody m_sleepingThreshold(float setter); + public native @Cast("btScalar") float m_maxSpeedSquared(); public native btSoftBody m_maxSpeedSquared(float setter); + public native @ByRef btAlignedObjectArray_btVector3 m_quads(); public native btSoftBody m_quads(btAlignedObjectArray_btVector3 setter); // quadrature points for collision detection + public native @Cast("btScalar") float m_repulsionStiffness(); public native btSoftBody m_repulsionStiffness(float setter); + public native @Cast("btScalar") float m_gravityFactor(); public native btSoftBody m_gravityFactor(float setter); + public native @Cast("bool") boolean m_cacheBarycenter(); public native btSoftBody m_cacheBarycenter(boolean setter); + public native @ByRef btAlignedObjectArray_btVector3 m_X(); public native btSoftBody m_X(btAlignedObjectArray_btVector3 setter); // initial positions + + public native @ByRef btAlignedObjectArray_btVector4 m_renderNodesInterpolationWeights(); public native btSoftBody m_renderNodesInterpolationWeights(btAlignedObjectArray_btVector4 setter); + + public native @ByRef btAlignedObjectArray_btScalar m_z(); public native btSoftBody m_z(btAlignedObjectArray_btScalar setter); // vertical distance used in extrapolation + public native @Cast("bool") boolean m_useSelfCollision(); public native btSoftBody m_useSelfCollision(boolean setter); + public native @Cast("bool") boolean m_softSoftCollision(); public native btSoftBody m_softSoftCollision(boolean setter); + + public native @ByRef btAlignedObjectArray_bool m_clusterConnectivity(); public native btSoftBody m_clusterConnectivity(btAlignedObjectArray_bool setter); //cluster connectivity, for self-collision + + public native @ByRef btVector3 m_windVelocity(); public native btSoftBody m_windVelocity(btVector3 setter); + + public native @Cast("btScalar") float m_restLengthScale(); public native btSoftBody m_restLengthScale(float setter); + + // + // Api + // + + /* ctor */ + public btSoftBody(btSoftBodyWorldInfo worldInfo, int node_count, @Const btVector3 x, @Cast("const btScalar*") FloatPointer m) { super((Pointer)null); allocate(worldInfo, node_count, x, m); } + private native void allocate(btSoftBodyWorldInfo worldInfo, int node_count, @Const btVector3 x, @Cast("const btScalar*") FloatPointer m); + public btSoftBody(btSoftBodyWorldInfo worldInfo, int node_count, @Const btVector3 x, @Cast("const btScalar*") FloatBuffer m) { super((Pointer)null); allocate(worldInfo, node_count, x, m); } + private native void allocate(btSoftBodyWorldInfo worldInfo, int node_count, @Const btVector3 x, @Cast("const btScalar*") FloatBuffer m); + public btSoftBody(btSoftBodyWorldInfo worldInfo, int node_count, @Const btVector3 x, @Cast("const btScalar*") float[] m) { super((Pointer)null); allocate(worldInfo, node_count, x, m); } + private native void allocate(btSoftBodyWorldInfo worldInfo, int node_count, @Const btVector3 x, @Cast("const btScalar*") float[] m); + + /* ctor */ + public btSoftBody(btSoftBodyWorldInfo worldInfo) { super((Pointer)null); allocate(worldInfo); } + private native void allocate(btSoftBodyWorldInfo worldInfo); + + public native void initDefaults(); + + /* dtor */ + /* Check for existing link */ + + public native @ByRef btAlignedObjectArray_int m_userIndexMapping(); public native btSoftBody m_userIndexMapping(btAlignedObjectArray_int setter); + + public native btSoftBodyWorldInfo getWorldInfo(); + + public native void setDampingCoefficient(@Cast("btScalar") float damping_coeff); + + /**\todo: avoid internal softbody shape hack and move collision code to collision library */ + public native void setCollisionShape(btCollisionShape collisionShape); + + public native @Cast("bool") boolean checkLink(int node0, + int node1); + public native @Cast("bool") boolean checkLink(@Const Node node0, + @Const Node node1); + /* Check for existing face */ + public native @Cast("bool") boolean checkFace(int node0, + int node1, + int node2); + /* Append material */ + public native Material appendMaterial(); + /* Append note */ + public native void appendNote(@Cast("const char*") BytePointer text, + @Const @ByRef btVector3 o, + @Const @ByRef(nullValue = "btVector4(1, 0, 0, 0)") btVector4 c, + Node n0/*=0*/, + Node n1/*=0*/, + Node n2/*=0*/, + Node n3/*=0*/); + public native void appendNote(@Cast("const char*") BytePointer text, + @Const @ByRef btVector3 o); + public native void appendNote(String text, + @Const @ByRef btVector3 o, + @Const @ByRef(nullValue = "btVector4(1, 0, 0, 0)") btVector4 c, + Node n0/*=0*/, + Node n1/*=0*/, + Node n2/*=0*/, + Node n3/*=0*/); + public native void appendNote(String text, + @Const @ByRef btVector3 o); + public native void appendNote(@Cast("const char*") BytePointer text, + @Const @ByRef btVector3 o, + Node feature); + public native void appendNote(String text, + @Const @ByRef btVector3 o, + Node feature); + public native void appendNote(@Cast("const char*") BytePointer text, + @Const @ByRef btVector3 o, + Link feature); + public native void appendNote(String text, + @Const @ByRef btVector3 o, + Link feature); + public native void appendNote(@Cast("const char*") BytePointer text, + @Const @ByRef btVector3 o, + Face feature); + public native void appendNote(String text, + @Const @ByRef btVector3 o, + Face feature); + /* Append node */ + public native void appendNode(@Const @ByRef btVector3 x, @Cast("btScalar") float m); + /* Append link */ + public native void appendLink(int model/*=-1*/, Material mat/*=0*/); + public native void appendLink(); + public native void appendLink(int node0, + int node1, + Material mat/*=0*/, + @Cast("bool") boolean bcheckexist/*=false*/); + public native void appendLink(int node0, + int node1); + public native void appendLink(Node node0, + Node node1, + Material mat/*=0*/, + @Cast("bool") boolean bcheckexist/*=false*/); + public native void appendLink(Node node0, + Node node1); + /* Append face */ + public native void appendFace(int model/*=-1*/, Material mat/*=0*/); + public native void appendFace(); + public native void appendFace(int node0, + int node1, + int node2, + Material mat/*=0*/); + public native void appendFace(int node0, + int node1, + int node2); + public native void appendTetra(int model, Material mat); + // + public native void appendTetra(int node0, + int node1, + int node2, + int node3, + Material mat/*=0*/); + public native void appendTetra(int node0, + int node1, + int node2, + int node3); + + /* Append anchor */ + public native void appendDeformableAnchor(int node, btRigidBody body); + public native void appendDeformableAnchor(int node, btMultiBodyLinkCollider link); + public native void appendAnchor(int node, + btRigidBody body, @Cast("bool") boolean disableCollisionBetweenLinkedBodies/*=false*/, @Cast("btScalar") float influence/*=1*/); + public native void appendAnchor(int node, + btRigidBody body); + public native void appendAnchor(int node, btRigidBody body, @Const @ByRef btVector3 localPivot, @Cast("bool") boolean disableCollisionBetweenLinkedBodies/*=false*/, @Cast("btScalar") float influence/*=1*/); + public native void appendAnchor(int node, btRigidBody body, @Const @ByRef btVector3 localPivot); + public native void removeAnchor(int node); + /* Append linear joint */ + public native void appendLinearJoint(@Const @ByRef LJoint.Specs specs, Cluster body0, @ByVal Body body1); + public native void appendLinearJoint(@Const @ByRef LJoint.Specs specs, @ByVal(nullValue = "btSoftBody::Body()") Body body); + public native void appendLinearJoint(@Const @ByRef LJoint.Specs specs); + public native void appendLinearJoint(@Const @ByRef LJoint.Specs specs, btSoftBody body); + /* Append linear joint */ + public native void appendAngularJoint(@Const @ByRef AJoint.Specs specs, Cluster body0, @ByVal Body body1); + public native void appendAngularJoint(@Const @ByRef AJoint.Specs specs, @ByVal(nullValue = "btSoftBody::Body()") Body body); + public native void appendAngularJoint(@Const @ByRef AJoint.Specs specs); + public native void appendAngularJoint(@Const @ByRef AJoint.Specs specs, btSoftBody body); + /* Add force (or gravity) to the entire body */ + public native void addForce(@Const @ByRef btVector3 force); + /* Add force (or gravity) to a node of the body */ + public native void addForce(@Const @ByRef btVector3 force, + int node); + /* Add aero force to a node of the body */ + public native void addAeroForceToNode(@Const @ByRef btVector3 windVelocity, int nodeIndex); + + /* Add aero force to a face of the body */ + public native void addAeroForceToFace(@Const @ByRef btVector3 windVelocity, int faceIndex); + + /* Add velocity to the entire body */ + public native void addVelocity(@Const @ByRef btVector3 velocity); + + /* Set velocity for the entire body */ + public native void setVelocity(@Const @ByRef btVector3 velocity); + + /* Add velocity to a node of the body */ + public native void addVelocity(@Const @ByRef btVector3 velocity, + int node); + /* Set mass */ + public native void setMass(int node, + @Cast("btScalar") float mass); + /* Get mass */ + public native @Cast("btScalar") float getMass(int node); + /* Get total mass */ + public native @Cast("btScalar") float getTotalMass(); + /* Set total mass (weighted by previous masses) */ + public native void setTotalMass(@Cast("btScalar") float mass, + @Cast("bool") boolean fromfaces/*=false*/); + public native void setTotalMass(@Cast("btScalar") float mass); + /* Set total density */ + public native void setTotalDensity(@Cast("btScalar") float density); + /* Set volume mass (using tetrahedrons) */ + public native void setVolumeMass(@Cast("btScalar") float mass); + /* Set volume density (using tetrahedrons) */ + public native void setVolumeDensity(@Cast("btScalar") float density); + /* Get the linear velocity of the center of mass */ + public native @ByVal btVector3 getLinearVelocity(); + /* Set the linear velocity of the center of mass */ + public native void setLinearVelocity(@Const @ByRef btVector3 linVel); + /* Set the angular velocity of the center of mass */ + public native void setAngularVelocity(@Const @ByRef btVector3 angVel); + /* Get best fit rigid transform */ + public native @ByVal btTransform getRigidTransform(); + /* Transform to given pose */ + public native void transformTo(@Const @ByRef btTransform trs); + /* Transform */ + public native void transform(@Const @ByRef btTransform trs); + /* Translate */ + public native void translate(@Const @ByRef btVector3 trs); + /* Rotate */ + public native void rotate(@Const @ByRef btQuaternion rot); + /* Scale */ + public native void scale(@Const @ByRef btVector3 scl); + /* Get link resting lengths scale */ + public native @Cast("btScalar") float getRestLengthScale(); + /* Scale resting length of all springs */ + public native void setRestLengthScale(@Cast("btScalar") float restLength); + /* Set current state as pose */ + public native void setPose(@Cast("bool") boolean bvolume, + @Cast("bool") boolean bframe); + /* Set current link lengths as resting lengths */ + public native void resetLinkRestLengths(); + /* Return the volume */ + public native @Cast("btScalar") float getVolume(); + /* Cluster count */ + public native @ByVal btVector3 getCenterOfMass(); + public native int clusterCount(); + /* Cluster center of mass */ + public static native @ByVal btVector3 clusterCom(@Const Cluster cluster); + public native @ByVal btVector3 clusterCom(int cluster); + /* Cluster velocity at rpos */ + public static native @ByVal btVector3 clusterVelocity(@Const Cluster cluster, @Const @ByRef btVector3 rpos); + /* Cluster impulse */ + public static native void clusterVImpulse(Cluster cluster, @Const @ByRef btVector3 rpos, @Const @ByRef btVector3 impulse); + public static native void clusterDImpulse(Cluster cluster, @Const @ByRef btVector3 rpos, @Const @ByRef btVector3 impulse); + public static native void clusterImpulse(Cluster cluster, @Const @ByRef btVector3 rpos, @Const @ByRef Impulse impulse); + public static native void clusterVAImpulse(Cluster cluster, @Const @ByRef btVector3 impulse); + public static native void clusterDAImpulse(Cluster cluster, @Const @ByRef btVector3 impulse); + public static native void clusterAImpulse(Cluster cluster, @Const @ByRef Impulse impulse); + public static native void clusterDCImpulse(Cluster cluster, @Const @ByRef btVector3 impulse); + /* Generate bending constraints based on distance in the adjency graph */ + public native int generateBendingConstraints(int distance, + Material mat/*=0*/); + public native int generateBendingConstraints(int distance); + /* Randomize constraints to reduce solver bias */ + public native void randomizeConstraints(); + /* Release clusters */ + public native void releaseCluster(int index); + public native void releaseClusters(); + /* Generate clusters (K-mean) */ + /**generateClusters with k=0 will create a convex cluster for each tetrahedron or triangle + /**otherwise an approximation will be used (better performance) */ + public native int generateClusters(int k, int maxiterations/*=8192*/); + public native int generateClusters(int k); + /* Refine */ + public native void refine(ImplicitFn ifn, @Cast("btScalar") float accurary, @Cast("bool") boolean cut); + /* CutLink */ + public native @Cast("bool") boolean cutLink(int node0, int node1, @Cast("btScalar") float _position); + public native @Cast("bool") boolean cutLink(@Const Node node0, @Const Node node1, @Cast("btScalar") float _position); + + /**Ray casting using rayFrom and rayTo in worldspace, (not direction!) */ + public native @Cast("bool") boolean rayTest(@Const @ByRef btVector3 rayFrom, + @Const @ByRef btVector3 rayTo, + @ByRef sRayCast results); + public native @Cast("bool") boolean rayFaceTest(@Const @ByRef btVector3 rayFrom, + @Const @ByRef btVector3 rayTo, + @ByRef sRayCast results); + public native int rayFaceTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, + @Cast("btScalar*") @ByRef FloatPointer mint, @ByRef IntPointer index); + public native int rayFaceTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, + @Cast("btScalar*") @ByRef FloatBuffer mint, @ByRef IntBuffer index); + public native int rayFaceTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, + @Cast("btScalar*") @ByRef float[] mint, @ByRef int[] index); + /* Solver presets */ + public native void setSolver(@Cast("btSoftBody::eSolverPresets::_") int preset); + /* predictMotion */ + public native void predictMotion(@Cast("btScalar") float dt); + /* solveConstraints */ + public native void solveConstraints(); + /* staticSolve */ + public native void staticSolve(int iterations); + /* solveCommonConstraints */ + public static native void solveCommonConstraints(@Cast("btSoftBody**") PointerPointer bodies, int count, int iterations); + public static native void solveCommonConstraints(@ByPtrPtr btSoftBody bodies, int count, int iterations); + /* solveClusters */ + + /* integrateMotion */ + public native void integrateMotion(); + /* defaultCollisionHandlers */ + public native void defaultCollisionHandler(@Const btCollisionObjectWrapper pcoWrap); + public native void defaultCollisionHandler(btSoftBody psb); + public native void setSelfCollision(@Cast("bool") boolean useSelfCollision); + public native @Cast("bool") boolean useSelfCollision(); + public native void updateDeactivation(@Cast("btScalar") float timeStep); + public native void setZeroVelocity(); + public native @Cast("bool") boolean wantsSleeping(); + + // + // Functionality to deal with new accelerated solvers. + // + + /** + * Set a wind velocity for interaction with the air. + */ + public native void setWindVelocity(@Const @ByRef btVector3 velocity); + + /** + * Return the wind velocity for interaction with the air. + */ + public native @Const @ByRef btVector3 getWindVelocity(); + + // + // Set the solver that handles this soft body + // Should not be allowed to get out of sync with reality + // Currently called internally on addition to the world + public native void setSoftBodySolver(btSoftBodySolver softBodySolver); + + // + // Return the solver that handles this soft body + // + public native btSoftBodySolver getSoftBodySolver(); + + // + // Return the solver that handles this soft body + // + + // + // Cast + // + + public static native @Const btSoftBody upcast(@Const btCollisionObject colObj); + + // + // ::btCollisionObject + // + + public native void getAabb(@ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + // + // Private + // + public native void pointersToIndices(); + public native void indicesToPointers(@Const IntPointer map/*=0*/); + public native void indicesToPointers(); + public native void indicesToPointers(@Const IntBuffer map/*=0*/); + public native void indicesToPointers(@Const int[] map/*=0*/); + + public native int rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, + @Cast("btScalar*") @ByRef FloatPointer mint, @Cast("btSoftBody::eFeature::_*") @ByRef IntPointer feature, @ByRef IntPointer index, @Cast("bool") boolean bcountonly); + public native int rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, + @Cast("btScalar*") @ByRef FloatBuffer mint, @Cast("btSoftBody::eFeature::_*") @ByRef IntBuffer feature, @ByRef IntBuffer index, @Cast("bool") boolean bcountonly); + public native int rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, + @Cast("btScalar*") @ByRef float[] mint, @Cast("btSoftBody::eFeature::_*") @ByRef int[] feature, @ByRef int[] index, @Cast("bool") boolean bcountonly); + public native void initializeFaceTree(); + public native void rebuildNodeTree(); + public native @ByVal btVector3 evaluateCom(); + public native @Cast("bool") boolean checkDeformableContact(@Const btCollisionObjectWrapper colObjWrap, @Const @ByRef btVector3 x, @Cast("btScalar") float margin, @ByRef sCti cti, @Cast("bool") boolean predict/*=false*/); + public native @Cast("bool") boolean checkDeformableContact(@Const btCollisionObjectWrapper colObjWrap, @Const @ByRef btVector3 x, @Cast("btScalar") float margin, @ByRef sCti cti); + public native @Cast("bool") boolean checkDeformableFaceContact(@Const btCollisionObjectWrapper colObjWrap, @ByRef Face f, @ByRef btVector3 contact_point, @ByRef btVector3 bary, @Cast("btScalar") float margin, @ByRef sCti cti, @Cast("bool") boolean predict/*=false*/); + public native @Cast("bool") boolean checkDeformableFaceContact(@Const btCollisionObjectWrapper colObjWrap, @ByRef Face f, @ByRef btVector3 contact_point, @ByRef btVector3 bary, @Cast("btScalar") float margin, @ByRef sCti cti); + public native @Cast("bool") boolean checkContact(@Const btCollisionObjectWrapper colObjWrap, @Const @ByRef btVector3 x, @Cast("btScalar") float margin, @ByRef sCti cti); + public native void updateNormals(); + public native void updateBounds(); + public native void updatePose(); + public native void updateConstants(); + public native void updateLinkConstants(); + public native void updateArea(@Cast("bool") boolean averageArea/*=true*/); + public native void updateArea(); + public native void initializeClusters(); + public native void updateClusters(); + public native void cleanupClusters(); + public native void prepareClusters(int iterations); + + public native void applyClusters(@Cast("bool") boolean drift); + public native void dampClusters(); + public native void setSpringStiffness(@Cast("btScalar") float k); + public native void setGravityFactor(@Cast("btScalar") float gravFactor); + public native void setCacheBarycenter(@Cast("bool") boolean cacheBarycenter); + public native void initializeDmInverse(); + public native void updateDeformation(); + public native void advanceDeformation(); + public native void applyForces(); + public native void setMaxStress(@Cast("btScalar") float maxStress); + public native void interpolateRenderMesh(); + public native void setCollisionQuadrature(int N); + public static native void PSolve_Anchors(btSoftBody psb, @Cast("btScalar") float kst, @Cast("btScalar") float ti); + public static native void PSolve_RContacts(btSoftBody psb, @Cast("btScalar") float kst, @Cast("btScalar") float ti); + public static native void PSolve_SContacts(btSoftBody psb, @Cast("btScalar") float arg1, @Cast("btScalar") float ti); + public static native void PSolve_Links(btSoftBody psb, @Cast("btScalar") float kst, @Cast("btScalar") float ti); + public static native void VSolve_Links(btSoftBody psb, @Cast("btScalar") float kst); + public static native psolver_t getSolver(@Cast("btSoftBody::ePSolver::_") int solver); + public native void geometricCollisionHandler(btSoftBody psb); +// #define SAFE_EPSILON SIMD_EPSILON * 100.0 + + + public native void updateNodeTree(@Cast("bool") boolean use_velocity, @Cast("bool") boolean margin); + public native void updateFaceTree(@Cast("bool") boolean use_velocity, @Cast("bool") boolean margin); + + public native void applyRepulsionForce(@Cast("btScalar") float timeStep, @Cast("bool") boolean applySpringForce); + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java new file mode 100644 index 00000000000..aface4ee22e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java @@ -0,0 +1,232 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyHelpers extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSoftBodyHelpers() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyHelpers(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyHelpers(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSoftBodyHelpers position(long position) { + return (btSoftBodyHelpers)super.position(position); + } + @Override public btSoftBodyHelpers getPointer(long i) { + return new btSoftBodyHelpers((Pointer)this).offsetAddress(i); + } + + /* Draw body */ + public static native void Draw(btSoftBody psb, + btIDebugDraw idraw, + int drawflags/*=fDrawFlags::Std*/); + public static native void Draw(btSoftBody psb, + btIDebugDraw idraw); + /* Draw body infos */ + public static native void DrawInfos(btSoftBody psb, + btIDebugDraw idraw, + @Cast("bool") boolean masses, + @Cast("bool") boolean areas, + @Cast("bool") boolean stress); + /* Draw node tree */ + public static native void DrawNodeTree(btSoftBody psb, + btIDebugDraw idraw, + int mindepth/*=0*/, + int maxdepth/*=-1*/); + public static native void DrawNodeTree(btSoftBody psb, + btIDebugDraw idraw); + /* Draw face tree */ + public static native void DrawFaceTree(btSoftBody psb, + btIDebugDraw idraw, + int mindepth/*=0*/, + int maxdepth/*=-1*/); + public static native void DrawFaceTree(btSoftBody psb, + btIDebugDraw idraw); + /* Draw cluster tree */ + public static native void DrawClusterTree(btSoftBody psb, + btIDebugDraw idraw, + int mindepth/*=0*/, + int maxdepth/*=-1*/); + public static native void DrawClusterTree(btSoftBody psb, + btIDebugDraw idraw); + /* Draw rigid frame */ + public static native void DrawFrame(btSoftBody psb, + btIDebugDraw idraw); + /* Create a rope */ + public static native btSoftBody CreateRope(@ByRef btSoftBodyWorldInfo worldInfo, + @Const @ByRef btVector3 from, + @Const @ByRef btVector3 to, + int res, + int fixeds); + /* Create a patch */ + public static native btSoftBody CreatePatch(@ByRef btSoftBodyWorldInfo worldInfo, + @Const @ByRef btVector3 corner00, + @Const @ByRef btVector3 corner10, + @Const @ByRef btVector3 corner01, + @Const @ByRef btVector3 corner11, + int resx, + int resy, + int fixeds, + @Cast("bool") boolean gendiags, + @Cast("btScalar") float perturbation/*=0.*/); + public static native btSoftBody CreatePatch(@ByRef btSoftBodyWorldInfo worldInfo, + @Const @ByRef btVector3 corner00, + @Const @ByRef btVector3 corner10, + @Const @ByRef btVector3 corner01, + @Const @ByRef btVector3 corner11, + int resx, + int resy, + int fixeds, + @Cast("bool") boolean gendiags); + /* Create a patch with UV Texture Coordinates */ + public static native btSoftBody CreatePatchUV(@ByRef btSoftBodyWorldInfo worldInfo, + @Const @ByRef btVector3 corner00, + @Const @ByRef btVector3 corner10, + @Const @ByRef btVector3 corner01, + @Const @ByRef btVector3 corner11, + int resx, + int resy, + int fixeds, + @Cast("bool") boolean gendiags, + FloatPointer tex_coords/*=0*/); + public static native btSoftBody CreatePatchUV(@ByRef btSoftBodyWorldInfo worldInfo, + @Const @ByRef btVector3 corner00, + @Const @ByRef btVector3 corner10, + @Const @ByRef btVector3 corner01, + @Const @ByRef btVector3 corner11, + int resx, + int resy, + int fixeds, + @Cast("bool") boolean gendiags); + public static native btSoftBody CreatePatchUV(@ByRef btSoftBodyWorldInfo worldInfo, + @Const @ByRef btVector3 corner00, + @Const @ByRef btVector3 corner10, + @Const @ByRef btVector3 corner01, + @Const @ByRef btVector3 corner11, + int resx, + int resy, + int fixeds, + @Cast("bool") boolean gendiags, + FloatBuffer tex_coords/*=0*/); + public static native btSoftBody CreatePatchUV(@ByRef btSoftBodyWorldInfo worldInfo, + @Const @ByRef btVector3 corner00, + @Const @ByRef btVector3 corner10, + @Const @ByRef btVector3 corner01, + @Const @ByRef btVector3 corner11, + int resx, + int resy, + int fixeds, + @Cast("bool") boolean gendiags, + float[] tex_coords/*=0*/); + public static native float CalculateUV(int resx, int resy, int ix, int iy, int id); + /* Create an ellipsoid */ + public static native btSoftBody CreateEllipsoid(@ByRef btSoftBodyWorldInfo worldInfo, + @Const @ByRef btVector3 center, + @Const @ByRef btVector3 radius, + int res); + /* Create from trimesh */ + public static native btSoftBody CreateFromTriMesh(@ByRef btSoftBodyWorldInfo worldInfo, + @Cast("const btScalar*") FloatPointer vertices, + @Const IntPointer triangles, + int ntriangles, + @Cast("bool") boolean randomizeConstraints/*=true*/); + public static native btSoftBody CreateFromTriMesh(@ByRef btSoftBodyWorldInfo worldInfo, + @Cast("const btScalar*") FloatPointer vertices, + @Const IntPointer triangles, + int ntriangles); + public static native btSoftBody CreateFromTriMesh(@ByRef btSoftBodyWorldInfo worldInfo, + @Cast("const btScalar*") FloatBuffer vertices, + @Const IntBuffer triangles, + int ntriangles, + @Cast("bool") boolean randomizeConstraints/*=true*/); + public static native btSoftBody CreateFromTriMesh(@ByRef btSoftBodyWorldInfo worldInfo, + @Cast("const btScalar*") FloatBuffer vertices, + @Const IntBuffer triangles, + int ntriangles); + public static native btSoftBody CreateFromTriMesh(@ByRef btSoftBodyWorldInfo worldInfo, + @Cast("const btScalar*") float[] vertices, + @Const int[] triangles, + int ntriangles, + @Cast("bool") boolean randomizeConstraints/*=true*/); + public static native btSoftBody CreateFromTriMesh(@ByRef btSoftBodyWorldInfo worldInfo, + @Cast("const btScalar*") float[] vertices, + @Const int[] triangles, + int ntriangles); + /* Create from convex-hull */ + public static native btSoftBody CreateFromConvexHull(@ByRef btSoftBodyWorldInfo worldInfo, + @Const btVector3 vertices, + int nvertices, + @Cast("bool") boolean randomizeConstraints/*=true*/); + public static native btSoftBody CreateFromConvexHull(@ByRef btSoftBodyWorldInfo worldInfo, + @Const btVector3 vertices, + int nvertices); + + /* Export TetGen compatible .smesh file */ + // static void ExportAsSMeshFile( btSoftBody* psb, + // const char* filename); + /* Create from TetGen .ele, .face, .node files */ + // static btSoftBody* CreateFromTetGenFile( btSoftBodyWorldInfo& worldInfo, + // const char* ele, + // const char* face, + // const char* node, + // bool bfacelinks, + // bool btetralinks, + // bool bfacesfromtetras); + /* Create from TetGen .ele, .face, .node data */ + public static native btSoftBody CreateFromTetGenData(@ByRef btSoftBodyWorldInfo worldInfo, + @Cast("const char*") BytePointer ele, + @Cast("const char*") BytePointer face, + @Cast("const char*") BytePointer node, + @Cast("bool") boolean bfacelinks, + @Cast("bool") boolean btetralinks, + @Cast("bool") boolean bfacesfromtetras); + public static native btSoftBody CreateFromTetGenData(@ByRef btSoftBodyWorldInfo worldInfo, + String ele, + String face, + String node, + @Cast("bool") boolean bfacelinks, + @Cast("bool") boolean btetralinks, + @Cast("bool") boolean bfacesfromtetras); + public static native btSoftBody CreateFromVtkFile(@ByRef btSoftBodyWorldInfo worldInfo, @Cast("const char*") BytePointer vtk_file); + public static native btSoftBody CreateFromVtkFile(@ByRef btSoftBodyWorldInfo worldInfo, String vtk_file); + + public static native void writeObj(@Cast("const char*") BytePointer file, @Const btSoftBody psb); + public static native void writeObj(String file, @Const btSoftBody psb); + + public static native void getBarycentricWeights(@Const @ByRef btVector3 a, @Const @ByRef btVector3 b, @Const @ByRef btVector3 c, @Const @ByRef btVector3 d, @Const @ByRef btVector3 p, @ByRef btVector4 bary); + + public static native void getBarycentricWeights(@Const @ByRef btVector3 a, @Const @ByRef btVector3 b, @Const @ByRef btVector3 c, @Const @ByRef btVector3 p, @ByRef btVector4 bary); + + public static native void interpolateBarycentricWeights(btSoftBody psb); + + public static native void extrapolateBarycentricWeights(btSoftBody psb); + + public static native void generateBoundaryFaces(btSoftBody psb); + + public static native void duplicateFaces(@Cast("const char*") BytePointer filename, @Const btSoftBody psb); + public static native void duplicateFaces(String filename, @Const btSoftBody psb); + /** Sort the list of links to move link calculations that are dependent upon earlier + * ones as far as possible away from the calculation of those values + * This tends to make adjacent loop iterations not dependent upon one another, + * so out-of-order processors can execute instructions from multiple iterations at once */ + public static native void ReoptimizeLinkOrder(btSoftBody psb); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java new file mode 100644 index 00000000000..3adc54507e7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyLinkData extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSoftBodyLinkData() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyLinkData(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java new file mode 100644 index 00000000000..d2a90ee3176 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/**btSoftBodyRigidBodyCollisionConfiguration add softbody interaction on top of btDefaultCollisionConfiguration */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyRigidBodyCollisionConfiguration extends btDefaultCollisionConfiguration { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyRigidBodyCollisionConfiguration(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyRigidBodyCollisionConfiguration(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSoftBodyRigidBodyCollisionConfiguration position(long position) { + return (btSoftBodyRigidBodyCollisionConfiguration)super.position(position); + } + @Override public btSoftBodyRigidBodyCollisionConfiguration getPointer(long i) { + return new btSoftBodyRigidBodyCollisionConfiguration((Pointer)this).offsetAddress(i); + } + + public btSoftBodyRigidBodyCollisionConfiguration(@Const @ByRef(nullValue = "btDefaultCollisionConstructionInfo()") btDefaultCollisionConstructionInfo constructionInfo) { super((Pointer)null); allocate(constructionInfo); } + private native void allocate(@Const @ByRef(nullValue = "btDefaultCollisionConstructionInfo()") btDefaultCollisionConstructionInfo constructionInfo); + public btSoftBodyRigidBodyCollisionConfiguration() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**creation of soft-soft and soft-rigid, and otherwise fallback to base class implementation */ + public native btCollisionAlgorithmCreateFunc getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java new file mode 100644 index 00000000000..50a47fe06ee --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodySolver extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodySolver(Pointer p) { super(p); } + + public enum SolverTypes { + DEFAULT_SOLVER(0), + CPU_SOLVER(1), + CL_SOLVER(2), + CL_SIMD_SOLVER(3), + DX_SOLVER(4), + DX_SIMD_SOLVER(5), + DEFORMABLE_SOLVER(6); + + public final int value; + private SolverTypes(int v) { this.value = v; } + private SolverTypes(SolverTypes e) { this.value = e.value; } + public SolverTypes intern() { for (SolverTypes e : values()) if (e.value == value) return e; return this; } + @Override public String toString() { return intern().name(); } + } + + /** + * Return the type of the solver. + */ + public native SolverTypes getSolverType(); + + /** Ensure that this solver is initialized. */ + public native @Cast("bool") boolean checkInitialized(); + + /** Optimize soft bodies in this solver. */ + public native void optimize(@ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("bool") boolean forceUpdate/*=false*/); + public native void optimize(@ByRef btAlignedObjectArray_btSoftBody softBodies); + + /** Copy necessary data back to the original soft body source objects. */ + public native void copyBackToSoftBodies(@Cast("bool") boolean bMove/*=true*/); + public native void copyBackToSoftBodies(); + + /** Predict motion of soft bodies into next timestep */ + public native void predictMotion(@Cast("btScalar") float solverdt); + + /** Solve constraints for a set of soft bodies */ + public native void solveConstraints(@Cast("btScalar") float solverdt); + + /** Perform necessary per-step updates of soft bodies such as recomputing normals and bounding boxes */ + public native void updateSoftBodies(); + + /** Process a collision between one of the world's soft bodies and another collision object */ + public native void processCollision(btSoftBody arg0, @Const btCollisionObjectWrapper arg1); + + /** Process a collision between two soft bodies */ + public native void processCollision(btSoftBody arg0, btSoftBody arg1); + + /** Set the number of velocity constraint solver iterations this solver uses. */ + public native void setNumberOfPositionIterations(int iterations); + + /** Get the number of velocity constraint solver iterations this solver uses. */ + public native int getNumberOfPositionIterations(); + + /** Set the number of velocity constraint solver iterations this solver uses. */ + public native void setNumberOfVelocityIterations(int iterations); + + /** Get the number of velocity constraint solver iterations this solver uses. */ + public native int getNumberOfVelocityIterations(); + + /** Return the timescale that the simulation is using */ + public native float getTimeScale(); + +// #if 0 +// #endif +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java new file mode 100644 index 00000000000..a99b2666836 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java @@ -0,0 +1,33 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/** + * Class to manage movement of data from a solver to a given target. + * This version is abstract. Subclasses will have custom pairings for different combinations. + */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodySolverOutput extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodySolverOutput(Pointer p) { super(p); } + + + /** Output current computed vertex data to the vertex buffers for all cloths in the solver. */ + public native void copySoftBodyToVertexBuffer(@Const btSoftBody softBody, btVertexBufferDescriptor vertexBuffer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java new file mode 100644 index 00000000000..3bd1e6152b6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyTriangleData extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSoftBodyTriangleData() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyTriangleData(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java new file mode 100644 index 00000000000..5fd2c95ed13 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyVertexData extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSoftBodyVertexData() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyVertexData(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java new file mode 100644 index 00000000000..2946b41cf6f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/* btSoftBodyWorldInfo */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyWorldInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyWorldInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyWorldInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSoftBodyWorldInfo position(long position) { + return (btSoftBodyWorldInfo)super.position(position); + } + @Override public btSoftBodyWorldInfo getPointer(long i) { + return new btSoftBodyWorldInfo((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float air_density(); public native btSoftBodyWorldInfo air_density(float setter); + public native @Cast("btScalar") float water_density(); public native btSoftBodyWorldInfo water_density(float setter); + public native @Cast("btScalar") float water_offset(); public native btSoftBodyWorldInfo water_offset(float setter); + public native @Cast("btScalar") float m_maxDisplacement(); public native btSoftBodyWorldInfo m_maxDisplacement(float setter); + public native @ByRef btVector3 water_normal(); public native btSoftBodyWorldInfo water_normal(btVector3 setter); + public native btBroadphaseInterface m_broadphase(); public native btSoftBodyWorldInfo m_broadphase(btBroadphaseInterface setter); + public native btDispatcher m_dispatcher(); public native btSoftBodyWorldInfo m_dispatcher(btDispatcher setter); + public native @ByRef btVector3 m_gravity(); public native btSoftBodyWorldInfo m_gravity(btVector3 setter); + public native @ByRef btSparseSdf_3 m_sparsesdf(); public native btSoftBodyWorldInfo m_sparsesdf(btSparseSdf_3 setter); + + public btSoftBodyWorldInfo() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java new file mode 100644 index 00000000000..ec4f358fae3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java @@ -0,0 +1,63 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +// #endif + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftMultiBodyDynamicsWorld(Pointer p) { super(p); } + + public btSoftMultiBodyDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btSoftBodySolver softBodySolver/*=0*/) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration, softBodySolver); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btSoftBodySolver softBodySolver/*=0*/); + public btSoftMultiBodyDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); + + public native void debugDrawWorld(); + + public native void addSoftBody(btSoftBody body, int collisionFilterGroup/*=btBroadphaseProxy::DefaultFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter*/); + public native void addSoftBody(btSoftBody body); + + public native void removeSoftBody(btSoftBody body); + + /**removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btDiscreteDynamicsWorld::removeCollisionObject */ + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native int getDrawFlags(); + public native void setDrawFlags(int f); + + public native @ByRef btSoftBodyWorldInfo getWorldInfo(); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBody getSoftBodyArray(); + + public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); + + /** rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest. + * In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape. + * This allows more customization. */ + public static native void rayTestSingle(@Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, + btCollisionObject collisionObject, + @Const btCollisionShape collisionShape, + @Const @ByRef btTransform colObjWorldTransform, + @ByRef RayResultCallback resultCallback); + + public native void serialize(btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java new file mode 100644 index 00000000000..cab662a89b5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftRigidDynamicsWorld extends btDiscreteDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftRigidDynamicsWorld(Pointer p) { super(p); } + + public btSoftRigidDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btSoftBodySolver softBodySolver/*=0*/) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration, softBodySolver); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btSoftBodySolver softBodySolver/*=0*/); + public btSoftRigidDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration); + + public native void debugDrawWorld(); + + public native void addSoftBody(btSoftBody body, int collisionFilterGroup/*=btBroadphaseProxy::DefaultFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter*/); + public native void addSoftBody(btSoftBody body); + + public native void removeSoftBody(btSoftBody body); + + /**removeCollisionObject will first check if it is a rigid body, if so call removeRigidBody otherwise call btDiscreteDynamicsWorld::removeCollisionObject */ + public native void removeCollisionObject(btCollisionObject collisionObject); + + public native int getDrawFlags(); + public native void setDrawFlags(int f); + + public native @ByRef btSoftBodyWorldInfo getWorldInfo(); + + public native @Cast("btDynamicsWorldType") int getWorldType(); + + public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBody getSoftBodyArray(); + + public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); + + /** rayTestSingle performs a raycast call and calls the resultCallback. It is used internally by rayTest. + * In a future implementation, we consider moving the ray test as a virtual method in btCollisionShape. + * This allows more customization. */ + public static native void rayTestSingle(@Const @ByRef btTransform rayFromTrans, @Const @ByRef btTransform rayToTrans, + btCollisionObject collisionObject, + @Const btCollisionShape collisionShape, + @Const @ByRef btTransform colObjWorldTransform, + @ByRef RayResultCallback resultCallback); + + public native void serialize(btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java new file mode 100644 index 00000000000..ef7dae5c2f7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java @@ -0,0 +1,85 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Name("btSparseSdf<3>") @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSparseSdf_3 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSparseSdf_3() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSparseSdf_3(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSparseSdf_3(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSparseSdf_3 position(long position) { + return (btSparseSdf_3)super.position(position); + } + @Override public btSparseSdf_3 getPointer(long i) { + return new btSparseSdf_3((Pointer)this).offsetAddress(i); + } + + // + // Inner types + // + // + // Fields + // + + + public native @Cast("btScalar") float voxelsz(); public native btSparseSdf_3 voxelsz(float setter); + public native @Cast("btScalar") float m_defaultVoxelsz(); public native btSparseSdf_3 m_defaultVoxelsz(float setter); + public native int puid(); public native btSparseSdf_3 puid(int setter); + public native int ncells(); public native btSparseSdf_3 ncells(int setter); + public native int m_clampCells(); public native btSparseSdf_3 m_clampCells(int setter); + public native int nprobes(); public native btSparseSdf_3 nprobes(int setter); + public native int nqueries(); public native btSparseSdf_3 nqueries(int setter); + // + // Methods + // + + // + public native void Initialize(int hashsize/*=2383*/, int clampCells/*=256 * 1024*/); + public native void Initialize(); + // + + public native void setDefaultVoxelsz(@Cast("btScalar") float sz); + + public native void Reset(); + // + public native void GarbageCollect(int lifetime/*=256*/); + public native void GarbageCollect(); + // + public native int RemoveReferences(btCollisionShape pcs); + // + public native @Cast("btScalar") float Evaluate(@Const @ByRef btVector3 x, + @Const btCollisionShape shape, + @ByRef btVector3 normal, + @Cast("btScalar") float margin); + // + // + public static native @Cast("btScalar") float DistanceToShape(@Const @ByRef btVector3 x, + @Const btCollisionShape shape); + // + // + public static native @Cast("btScalar") float Lerp(@Cast("btScalar") float a, @Cast("btScalar") float b, @Cast("btScalar") float t); + + // + public static native @Cast("unsigned int") int Hash(int x, int y, int z, @Const btCollisionShape shape); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java new file mode 100644 index 00000000000..8af3e3485c7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btVertexBufferDescriptor extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btVertexBufferDescriptor() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVertexBufferDescriptor(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVoronoiSimplexSolver.java new file mode 100644 index 00000000000..16102b985d9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVoronoiSimplexSolver.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btVoronoiSimplexSolver extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btVoronoiSimplexSolver() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVoronoiSimplexSolver(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java new file mode 100644 index 00000000000..4039b555268 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java @@ -0,0 +1,60 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +// +// Helpers +// + +/* fDrawFlags */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class fDrawFlags extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public fDrawFlags() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public fDrawFlags(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public fDrawFlags(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public fDrawFlags position(long position) { + return (fDrawFlags)super.position(position); + } + @Override public fDrawFlags getPointer(long i) { + return new fDrawFlags((Pointer)this).offsetAddress(i); + } + + /** enum fDrawFlags::_ */ + public static final int + Nodes = 0x0001, + Links = 0x0002, + Faces = 0x0004, + Tetras = 0x0008, + Normals = 0x0010, + Contacts = 0x0020, + Anchors = 0x0040, + Notes = 0x0080, + Clusters = 0x0100, + NodeTree = 0x0200, + FaceTree = 0x0400, + ClusterTree = 0x0800, + Joints = 0x1000, + /* presets */ + Std = Links + Faces + Tetras + Anchors + Notes + Joints, + StdTetra = Std - Faces + Tetras; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java new file mode 100644 index 00000000000..4b875125dc2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedObjectArray_bool extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_bool(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_bool(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_bool position(long position) { + return (btAlignedObjectArray_bool)super.position(position); + } + @Override public btAlignedObjectArray_bool getPointer(long i) { + return new btAlignedObjectArray_bool((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_bool put(@Const @ByRef btAlignedObjectArray_bool other); + public btAlignedObjectArray_bool() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_bool(@Const @ByRef btAlignedObjectArray_bool otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_bool otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @Cast("bool*") @ByRef BoolPointer at(int n); + + public native @Cast("bool*") @ByRef @Name("operator []") BoolPointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Cast("const bool") boolean fillData/*=bool()*/); + public native void resize(int newsize); + public native @Cast("bool*") @ByRef BoolPointer expandNonInitializing(); + + public native @Cast("bool*") @ByRef BoolPointer expand(@Cast("const bool") boolean fillValue/*=bool()*/); + public native @Cast("bool*") @ByRef BoolPointer expand(); + + public native void push_back(@Cast("const bool") boolean _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Cast("const bool") boolean key); + + public native int findLinearSearch(@Cast("const bool") boolean key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Cast("const bool") boolean key); + + public native void removeAtIndex(int index); + public native void remove(@Cast("const bool") boolean key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_bool otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java new file mode 100644 index 00000000000..2d0a5c4b5fc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedObjectArray_btMatrix3x3 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btMatrix3x3(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btMatrix3x3(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btMatrix3x3 position(long position) { + return (btAlignedObjectArray_btMatrix3x3)super.position(position); + } + @Override public btAlignedObjectArray_btMatrix3x3 getPointer(long i) { + return new btAlignedObjectArray_btMatrix3x3((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btMatrix3x3 put(@Const @ByRef btAlignedObjectArray_btMatrix3x3 other); + public btAlignedObjectArray_btMatrix3x3() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btMatrix3x3(@Const @ByRef btAlignedObjectArray_btMatrix3x3 otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btMatrix3x3 otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btMatrix3x3 at(int n); + + public native @ByRef @Name("operator []") btMatrix3x3 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btMatrix3x3()") btMatrix3x3 fillData); + public native void resize(int newsize); + public native @ByRef btMatrix3x3 expandNonInitializing(); + + public native @ByRef btMatrix3x3 expand(@Const @ByRef(nullValue = "btMatrix3x3()") btMatrix3x3 fillValue); + public native @ByRef btMatrix3x3 expand(); + + public native void push_back(@Const @ByRef btMatrix3x3 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + public native int findLinearSearch(@Const @ByRef btMatrix3x3 key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Const @ByRef btMatrix3x3 key); + + public native void removeAtIndex(int index); + public native void remove(@Const @ByRef btMatrix3x3 key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btMatrix3x3 otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java new file mode 100644 index 00000000000..6724fbceb41 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedObjectArray_btQuaternion extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btQuaternion(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btQuaternion(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btQuaternion position(long position) { + return (btAlignedObjectArray_btQuaternion)super.position(position); + } + @Override public btAlignedObjectArray_btQuaternion getPointer(long i) { + return new btAlignedObjectArray_btQuaternion((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btQuaternion put(@Const @ByRef btAlignedObjectArray_btQuaternion other); + public btAlignedObjectArray_btQuaternion() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btQuaternion(@Const @ByRef btAlignedObjectArray_btQuaternion otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btQuaternion otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btQuaternion at(int n); + + public native @ByRef @Name("operator []") btQuaternion get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btQuaternion()") btQuaternion fillData); + public native void resize(int newsize); + public native @ByRef btQuaternion expandNonInitializing(); + + public native @ByRef btQuaternion expand(@Const @ByRef(nullValue = "btQuaternion()") btQuaternion fillValue); + public native @ByRef btQuaternion expand(); + + public native void push_back(@Const @ByRef btQuaternion _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Const @ByRef btQuaternion key); + + public native int findLinearSearch(@Const @ByRef btQuaternion key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Const @ByRef btQuaternion key); + + public native void removeAtIndex(int index); + public native void remove(@Const @ByRef btQuaternion key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btQuaternion otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java index 18423f897ca..81eb5f4fb55 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java @@ -9,11 +9,7 @@ import static org.bytedeco.javacpp.presets.javacpp.*; import static org.bytedeco.bullet.global.LinearMath.*; - //for placement new -// #endif //BT_USE_PLACEMENT_NEW -/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) public class btAlignedObjectArray_btVector3 extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java new file mode 100644 index 00000000000..d987b79ca65 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedObjectArray_btVector4 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btVector4(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btVector4(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btVector4 position(long position) { + return (btAlignedObjectArray_btVector4)super.position(position); + } + @Override public btAlignedObjectArray_btVector4 getPointer(long i) { + return new btAlignedObjectArray_btVector4((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btVector4 put(@Const @ByRef btAlignedObjectArray_btVector4 other); + public btAlignedObjectArray_btVector4() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btVector4(@Const @ByRef btAlignedObjectArray_btVector4 otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btVector4 otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btVector4 at(int n); + + public native @ByRef @Name("operator []") btVector4 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btVector4()") btVector4 fillData); + public native void resize(int newsize); + public native @ByRef btVector4 expandNonInitializing(); + + public native @ByRef btVector4 expand(@Const @ByRef(nullValue = "btVector4()") btVector4 fillValue); + public native @ByRef btVector4 expand(); + + public native void push_back(@Const @ByRef btVector4 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Const @ByRef btVector4 key); + + public native int findLinearSearch(@Const @ByRef btVector4 key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Const @ByRef btVector4 key); + + public native void removeAtIndex(int index); + public native void remove(@Const @ByRef btVector4 key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btVector4 otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java new file mode 100644 index 00000000000..6c6c8bf92d4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedObjectArray_int extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_int(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_int(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_int position(long position) { + return (btAlignedObjectArray_int)super.position(position); + } + @Override public btAlignedObjectArray_int getPointer(long i) { + return new btAlignedObjectArray_int((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_int put(@Const @ByRef btAlignedObjectArray_int other); + public btAlignedObjectArray_int() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_int(@Const @ByRef btAlignedObjectArray_int otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_int otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef IntPointer at(int n); + + public native @ByRef @Name("operator []") IntPointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, int fillData/*=int()*/); + public native void resize(int newsize); + public native @ByRef IntPointer expandNonInitializing(); + + public native @ByRef IntPointer expand(int fillValue/*=int()*/); + public native @ByRef IntPointer expand(); + + public native void push_back(int _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(int key); + + public native int findLinearSearch(int key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(int key); + + public native void removeAtIndex(int index); + public native void remove(int key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_int otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialForceVector.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialForceVector.java new file mode 100644 index 00000000000..18526f3b442 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialForceVector.java @@ -0,0 +1,63 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btSpatialForceVector extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSpatialForceVector(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSpatialForceVector(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSpatialForceVector position(long position) { + return (btSpatialForceVector)super.position(position); + } + @Override public btSpatialForceVector getPointer(long i) { + return new btSpatialForceVector((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_topVec(); public native btSpatialForceVector m_topVec(btVector3 setter); + public native @ByRef btVector3 m_bottomVec(); public native btSpatialForceVector m_bottomVec(btVector3 setter); + // + public btSpatialForceVector() { super((Pointer)null); allocate(); } + private native void allocate(); + public btSpatialForceVector(@Const @ByRef btVector3 angular, @Const @ByRef btVector3 linear) { super((Pointer)null); allocate(angular, linear); } + private native void allocate(@Const @ByRef btVector3 angular, @Const @ByRef btVector3 linear); + public btSpatialForceVector(@Cast("const btScalar") float ax, @Cast("const btScalar") float ay, @Cast("const btScalar") float az, @Cast("const btScalar") float lx, @Cast("const btScalar") float ly, @Cast("const btScalar") float lz) { super((Pointer)null); allocate(ax, ay, az, lx, ly, lz); } + private native void allocate(@Cast("const btScalar") float ax, @Cast("const btScalar") float ay, @Cast("const btScalar") float az, @Cast("const btScalar") float lx, @Cast("const btScalar") float ly, @Cast("const btScalar") float lz); + // + public native void setVector(@Const @ByRef btVector3 angular, @Const @ByRef btVector3 linear); + public native void setValue(@Cast("const btScalar") float ax, @Cast("const btScalar") float ay, @Cast("const btScalar") float az, @Cast("const btScalar") float lx, @Cast("const btScalar") float ly, @Cast("const btScalar") float lz); + // + public native void addVector(@Const @ByRef btVector3 angular, @Const @ByRef btVector3 linear); + public native void addValue(@Cast("const btScalar") float ax, @Cast("const btScalar") float ay, @Cast("const btScalar") float az, @Cast("const btScalar") float lx, @Cast("const btScalar") float ly, @Cast("const btScalar") float lz); + // + public native @Const @ByRef btVector3 getLinear(); + public native @Const @ByRef btVector3 getAngular(); + // + public native void setLinear(@Const @ByRef btVector3 linear); + public native void setAngular(@Const @ByRef btVector3 angular); + // + public native void addAngular(@Const @ByRef btVector3 angular); + public native void addLinear(@Const @ByRef btVector3 linear); + // + public native void setZero(); + // + public native @ByRef @Name("operator +=") btSpatialForceVector addPut(@Const @ByRef btSpatialForceVector vec); + public native @ByRef @Name("operator -=") btSpatialForceVector subtractPut(@Const @ByRef btSpatialForceVector vec); + public native @ByVal @Name("operator -") btSpatialForceVector subtract(@Const @ByRef btSpatialForceVector vec); + public native @ByVal @Name("operator +") btSpatialForceVector add(@Const @ByRef btSpatialForceVector vec); + public native @ByVal @Name("operator -") btSpatialForceVector subtract(); + public native @ByVal @Name("operator *") btSpatialForceVector multiply(@Cast("const btScalar") float s); + //btSpatialForceVector & operator = (const btSpatialForceVector &vec) { m_topVec = vec.m_topVec; m_bottomVec = vec.m_bottomVec; return *this; } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java new file mode 100644 index 00000000000..ff57213ae99 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btSpatialMotionVector extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSpatialMotionVector(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSpatialMotionVector(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSpatialMotionVector position(long position) { + return (btSpatialMotionVector)super.position(position); + } + @Override public btSpatialMotionVector getPointer(long i) { + return new btSpatialMotionVector((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_topVec(); public native btSpatialMotionVector m_topVec(btVector3 setter); + public native @ByRef btVector3 m_bottomVec(); public native btSpatialMotionVector m_bottomVec(btVector3 setter); + // + public btSpatialMotionVector() { super((Pointer)null); allocate(); } + private native void allocate(); + public btSpatialMotionVector(@Const @ByRef btVector3 angular, @Const @ByRef btVector3 linear) { super((Pointer)null); allocate(angular, linear); } + private native void allocate(@Const @ByRef btVector3 angular, @Const @ByRef btVector3 linear); + // + public native void setVector(@Const @ByRef btVector3 angular, @Const @ByRef btVector3 linear); + public native void setValue(@Cast("const btScalar") float ax, @Cast("const btScalar") float ay, @Cast("const btScalar") float az, @Cast("const btScalar") float lx, @Cast("const btScalar") float ly, @Cast("const btScalar") float lz); + // + public native void addVector(@Const @ByRef btVector3 angular, @Const @ByRef btVector3 linear); + public native void addValue(@Cast("const btScalar") float ax, @Cast("const btScalar") float ay, @Cast("const btScalar") float az, @Cast("const btScalar") float lx, @Cast("const btScalar") float ly, @Cast("const btScalar") float lz); + // + public native @Const @ByRef btVector3 getAngular(); + public native @Const @ByRef btVector3 getLinear(); + // + public native void setAngular(@Const @ByRef btVector3 angular); + public native void setLinear(@Const @ByRef btVector3 linear); + // + public native void addAngular(@Const @ByRef btVector3 angular); + public native void addLinear(@Const @ByRef btVector3 linear); + // + public native void setZero(); + // + public native @Cast("btScalar") float dot(@Const @ByRef btSpatialForceVector b); + // + // + public native @ByRef @Name("operator +=") btSpatialMotionVector addPut(@Const @ByRef btSpatialMotionVector vec); + public native @ByRef @Name("operator -=") btSpatialMotionVector subtractPut(@Const @ByRef btSpatialMotionVector vec); + public native @ByRef @Name("operator *=") btSpatialMotionVector multiplyPut(@Cast("const btScalar") float s); + public native @ByVal @Name("operator -") btSpatialMotionVector subtract(@Const @ByRef btSpatialMotionVector vec); + public native @ByVal @Name("operator +") btSpatialMotionVector add(@Const @ByRef btSpatialMotionVector vec); + public native @ByVal @Name("operator -") btSpatialMotionVector subtract(); + public native @ByVal @Name("operator *") btSpatialMotionVector multiply(@Cast("const btScalar") float s); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialTransformationMatrix.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialTransformationMatrix.java new file mode 100644 index 00000000000..8fd06737c03 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialTransformationMatrix.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btSpatialTransformationMatrix extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSpatialTransformationMatrix() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSpatialTransformationMatrix(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSpatialTransformationMatrix(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSpatialTransformationMatrix position(long position) { + return (btSpatialTransformationMatrix)super.position(position); + } + @Override public btSpatialTransformationMatrix getPointer(long i) { + return new btSpatialTransformationMatrix((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3 m_rotMat(); public native btSpatialTransformationMatrix m_rotMat(btMatrix3x3 setter); //btMatrix3x3 m_trnCrossMat; + public native @ByRef btVector3 m_trnVec(); public native btSpatialTransformationMatrix m_trnVec(btVector3 setter); + // + /** enum btSpatialTransformationMatrix::eOutputOperation */ + public static final int + None = 0, + Add = 1, + Subtract = 2; + // + + public native void transformInverse(@Const @ByRef btSymmetricSpatialDyad inMat, + @ByRef btSymmetricSpatialDyad outMat, + @Cast("btSpatialTransformationMatrix::eOutputOperation") int outOp/*=btSpatialTransformationMatrix::None*/); + public native void transformInverse(@Const @ByRef btSymmetricSpatialDyad inMat, + @ByRef btSymmetricSpatialDyad outMat); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java new file mode 100644 index 00000000000..04672e5d32f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btSymmetricSpatialDyad extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSymmetricSpatialDyad(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSymmetricSpatialDyad(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSymmetricSpatialDyad position(long position) { + return (btSymmetricSpatialDyad)super.position(position); + } + @Override public btSymmetricSpatialDyad getPointer(long i) { + return new btSymmetricSpatialDyad((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3 m_topLeftMat(); public native btSymmetricSpatialDyad m_topLeftMat(btMatrix3x3 setter); + public native @ByRef btMatrix3x3 m_topRightMat(); public native btSymmetricSpatialDyad m_topRightMat(btMatrix3x3 setter); + public native @ByRef btMatrix3x3 m_bottomLeftMat(); public native btSymmetricSpatialDyad m_bottomLeftMat(btMatrix3x3 setter); + // + public btSymmetricSpatialDyad() { super((Pointer)null); allocate(); } + private native void allocate(); + public btSymmetricSpatialDyad(@Const @ByRef btMatrix3x3 topLeftMat, @Const @ByRef btMatrix3x3 topRightMat, @Const @ByRef btMatrix3x3 bottomLeftMat) { super((Pointer)null); allocate(topLeftMat, topRightMat, bottomLeftMat); } + private native void allocate(@Const @ByRef btMatrix3x3 topLeftMat, @Const @ByRef btMatrix3x3 topRightMat, @Const @ByRef btMatrix3x3 bottomLeftMat); + // + public native void setMatrix(@Const @ByRef btMatrix3x3 topLeftMat, @Const @ByRef btMatrix3x3 topRightMat, @Const @ByRef btMatrix3x3 bottomLeftMat); + // + public native void addMatrix(@Const @ByRef btMatrix3x3 topLeftMat, @Const @ByRef btMatrix3x3 topRightMat, @Const @ByRef btMatrix3x3 bottomLeftMat); + // + public native void setIdentity(); + // + public native @ByRef @Name("operator -=") btSymmetricSpatialDyad subtractPut(@Const @ByRef btSymmetricSpatialDyad mat); + // + public native @ByVal @Name("operator *") btSpatialForceVector multiply(@Const @ByRef btSpatialMotionVector vec); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index f40150c9076..305eefbae81 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -136,9 +136,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // Targeting ../BulletCollision/btCollisionObjectWrapper.java -// Targeting ../BulletCollision/btPersistentManifold.java - - // Targeting ../BulletCollision/btPoolAllocator.java @@ -554,6 +551,82 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H +// Parsed from BulletCollision/NarrowPhaseCollision/btPersistentManifold.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_PERSISTENT_MANIFOLD_H +// #define BT_PERSISTENT_MANIFOLD_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "btManifoldPoint.h" +// #include "LinearMath/btAlignedAllocator.h" +// Targeting ../BulletCollision/btCollisionResult.java + + + +/**maximum contact breaking and merging threshold */ +public static native @Cast("btScalar") float gContactBreakingThreshold(); public static native void gContactBreakingThreshold(float setter); +// Targeting ../BulletCollision/ContactDestroyedCallback.java + + +// Targeting ../BulletCollision/ContactProcessedCallback.java + + +// Targeting ../BulletCollision/ContactStartedCallback.java + + +// Targeting ../BulletCollision/ContactEndedCallback.java + + + + + + +// #endif //SWIG + +//the enum starts at 1024 to avoid type conflicts with btTypedConstraint +/** enum btContactManifoldTypes */ +public static final int + MIN_CONTACT_MANIFOLD_TYPE = 1024, + BT_PERSISTENT_MANIFOLD_TYPE = 1025; + +public static final int MANIFOLD_CACHE_SIZE = 4; +// Targeting ../BulletCollision/btPersistentManifold.java + + +// Targeting ../BulletCollision/btPersistentManifoldDoubleData.java + + +// Targeting ../BulletCollision/btPersistentManifoldFloatData.java + + + +// clang-format on + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btPersistentManifoldData btPersistentManifoldFloatData +public static final String btPersistentManifoldDataName = "btPersistentManifoldFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +// #endif //BT_PERSISTENT_MANIFOLD_H + + // Parsed from BulletCollision/CollisionDispatch/btCollisionObject.h /* diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index 1b33c260c15..420d6f6834e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -57,7 +57,7 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java +// Targeting ../BulletDynamics/btAlignedObjectArray_btRigidBody.java @@ -251,9 +251,6 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // Targeting ../BulletDynamics/btSimulationIslandManager.java -// Targeting ../BulletDynamics/btPersistentManifold.java - - // Targeting ../BulletDynamics/InplaceSolverIslandCallback.java @@ -1067,4 +1064,277 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_RAYCASTVEHICLE_H +// Parsed from BulletDynamics/Featherstone/btMultiBodyJointFeedback.h + +/* +Copyright (c) 2015 Google Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_JOINT_FEEDBACK_H +// #define BT_MULTIBODY_JOINT_FEEDBACK_H + +// #include "LinearMath/btSpatialAlgebra.h" +// Targeting ../BulletDynamics/btMultiBodyJointFeedback.java + + + +// #endif //BT_MULTIBODY_JOINT_FEEDBACK_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyLink.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_LINK_H +// #define BT_MULTIBODY_LINK_H + +// #include "LinearMath/btQuaternion.h" +// #include "LinearMath/btVector3.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" + +/** enum btMultiBodyLinkFlags */ +public static final int + BT_MULTIBODYLINKFLAGS_DISABLE_PARENT_COLLISION = 1, + BT_MULTIBODYLINKFLAGS_DISABLE_ALL_PARENT_COLLISION = 2; + +//both defines are now permanently enabled +// #define BT_MULTIBODYLINK_INCLUDE_PLANAR_JOINTS +// #define TEST_SPATIAL_ALGEBRA_LAYER + +// +// Various spatial helper functions +// + +//namespace { + +// #include "LinearMath/btSpatialAlgebra.h" +// Targeting ../BulletDynamics/btMultibodyLink.java + + + +// #endif //BT_MULTIBODY_LINK_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBody.h + +/* + * PURPOSE: + * Class representing an articulated rigid body. Stores the body's + * current state, allows forces and torques to be set, handles + * timestepping and implements Featherstone's algorithm. + * + * COPYRIGHT: + * Copyright (C) Stephen Thompson, , 2011-2013 + * Portions written By Erwin Coumans: connection to LCP solver, various multibody constraints, replacing Eigen math library by Bullet LinearMath and a dedicated 6x6 matrix inverse (solveImatrix) + * Portions written By Jakub Stepien: support for multi-DOF constraints, introduction of spatial algebra and several other improvements + + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + */ + +// #ifndef BT_MULTIBODY_H +// #define BT_MULTIBODY_H + +// #include "LinearMath/btScalar.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btQuaternion.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "LinearMath/btAlignedObjectArray.h" + +/**serialization data, don't change them if you are not familiar with the details of the serialization mechanisms */ +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btMultiBodyData btMultiBodyFloatData +public static final String btMultiBodyDataName = "btMultiBodyFloatData"; +// #define btMultiBodyLinkData btMultiBodyLinkFloatData +public static final String btMultiBodyLinkDataName = "btMultiBodyLinkFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +// #include "btMultiBodyLink.h" +// Targeting ../BulletDynamics/btMultiBody.java + + +// Targeting ../BulletDynamics/btMultiBodyLinkDoubleData.java + + +// Targeting ../BulletDynamics/btMultiBodyLinkFloatData.java + + +// Targeting ../BulletDynamics/btMultiBodyDoubleData.java + + +// Targeting ../BulletDynamics/btMultiBodyFloatData.java + + + +// #endif + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyLinkCollider.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_FEATHERSTONE_LINK_COLLIDER_H +// #define BT_FEATHERSTONE_LINK_COLLIDER_H + +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" + +// #include "btMultiBody.h" +// #include "LinearMath/btSerializer.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btMultiBodyLinkColliderData btMultiBodyLinkColliderFloatData +public static final String btMultiBodyLinkColliderDataName = "btMultiBodyLinkColliderFloatData"; +// Targeting ../BulletDynamics/btMultiBodyLinkCollider.java + + +// Targeting ../BulletDynamics/btMultiBodyLinkColliderFloatData.java + + +// Targeting ../BulletDynamics/btMultiBodyLinkColliderDoubleData.java + + + +// clang-format on + + + + + +// #endif //BT_FEATHERSTONE_LINK_COLLIDER_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_CONSTRAINT_H +// #define BT_MULTIBODY_CONSTRAINT_H + +// #include "LinearMath/btScalar.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btMultiBody.h" + + +//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility +/** enum btTypedMultiBodyConstraintType */ +public static final int + MULTIBODY_CONSTRAINT_LIMIT = 3, + MULTIBODY_CONSTRAINT_1DOF_JOINT_MOTOR = 4, + MULTIBODY_CONSTRAINT_GEAR = 5, + MULTIBODY_CONSTRAINT_POINT_TO_POINT = 6, + MULTIBODY_CONSTRAINT_SLIDER = 7, + MULTIBODY_CONSTRAINT_SPHERICAL_MOTOR = 8, + MULTIBODY_CONSTRAINT_FIXED = 9, + + MAX_MULTIBODY_CONSTRAINT_TYPE = 10; +// Targeting ../BulletDynamics/btSolverInfo.java + + + +// #include "btMultiBodySolverConstraint.h" +// Targeting ../BulletDynamics/btMultiBodyJacobianData.java + + +// Targeting ../BulletDynamics/btMultiBodyConstraint.java + + + +// #endif //BT_MULTIBODY_CONSTRAINT_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_DYNAMICS_WORLD_H +// #define BT_MULTIBODY_DYNAMICS_WORLD_H + +// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" +// #include "BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h" + +// #define BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY +// Targeting ../BulletDynamics/btMultiBodyConstraintSolver.java + + +// Targeting ../BulletDynamics/MultiBodyInplaceSolverIslandCallback.java + + +// Targeting ../BulletDynamics/btMultiBodyDynamicsWorld.java + + +// #endif //BT_MULTIBODY_DYNAMICS_WORLD_H + + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java new file mode 100644 index 00000000000..2b4db8fb307 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -0,0 +1,447 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.global; + +import org.bytedeco.bullet.BulletSoftBody.*; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { + static { Loader.load(); } + +// Parsed from LinearMath/btAlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBJECT_ARRAY__ +// #define BT_OBJECT_ARRAY__ + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +// #include "btAlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW + * then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int BT_USE_PLACEMENT_NEW = 1; +//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef BT_USE_MEMCPY +// #include +// #include +// #endif //BT_USE_MEMCPY + +// #ifdef BT_USE_PLACEMENT_NEW +// #include +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody.java + + + +// #endif //BT_OBJECT_ARRAY__ + + +// Parsed from BulletSoftBody/btSparseSDF.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**btSparseSdf implementation by Nathanael Presson */ + +// #ifndef BT_SPARSE_SDF_H +// #define BT_SPARSE_SDF_H + +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +// #include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" + +// Fast Hash + +// #if !defined(get16bits) +// #define get16bits(d) ((((unsigned int)(((const unsigned char*)(d))[1])) << 8) + (unsigned int)(((const unsigned char*)(d))[0])) +// #endif +// +// super hash function by Paul Hsieh +// +public static native @Cast("unsigned int") int HsiehHash(@Cast("const char*") BytePointer data, int len); +public static native @Cast("unsigned int") int HsiehHash(String data, int len); +// Targeting ../BulletSoftBody/btSparseSdf_3.java + + + +// #endif //BT_SPARSE_SDF_H + + +// Parsed from BulletSoftBody/btSoftBody.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**btSoftBody implementation by Nathanael Presson */ + +// #ifndef _BT_SOFT_BODY_H +// #define _BT_SOFT_BODY_H + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btIDebugDraw.h" +// #include "LinearMath/btVector3.h" +// #include "BulletDynamics/Dynamics/btRigidBody.h" + +// #include "BulletCollision/CollisionShapes/btConcaveShape.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "btSparseSDF.h" +// #include "BulletCollision/BroadphaseCollision/btDbvt.h" +// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" +//#ifdef BT_USE_DOUBLE_PRECISION +//#define btRigidBodyData btRigidBodyDoubleData +//#define btRigidBodyDataName "btRigidBodyDoubleData" +//#else +// #define btSoftBodyData btSoftBodyFloatData +public static final String btSoftBodyDataName = "btSoftBodyFloatData"; +@MemberGetter public static native @Cast("const btScalar") float OVERLAP_REDUCTION_FACTOR(); +public static final float OVERLAP_REDUCTION_FACTOR = OVERLAP_REDUCTION_FACTOR(); +public static native @Cast("unsigned long") long seed(); public static native void seed(long setter); +//#endif //BT_USE_DOUBLE_PRECISION +// Targeting ../BulletSoftBody/btSoftBodyWorldInfo.java + + +// Targeting ../BulletSoftBody/btSoftBody.java + + + +// #endif //_BT_SOFT_BODY_H + + +// Parsed from BulletSoftBody/btSoftRigidDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFT_RIGID_DYNAMICS_WORLD_H +// #define BT_SOFT_RIGID_DYNAMICS_WORLD_H + +// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" +// #include "btSoftBody.h" +// Targeting ../BulletSoftBody/btSoftRigidDynamicsWorld.java + + + +// #endif //BT_SOFT_RIGID_DYNAMICS_WORLD_H + + +// Parsed from BulletSoftBody/btSoftBodyHelpers.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFT_BODY_HELPERS_H +// #define BT_SOFT_BODY_HELPERS_H + +// #include "btSoftBody.h" +// #include +// #include +// Targeting ../BulletSoftBody/fDrawFlags.java + + +// Targeting ../BulletSoftBody/btSoftBodyHelpers.java + + + +// #endif //BT_SOFT_BODY_HELPERS_H + + +// Parsed from BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION +// #define BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION + +// #include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" +// Targeting ../BulletSoftBody/btVoronoiSimplexSolver.java + + +// Targeting ../BulletSoftBody/btGjkEpaPenetrationDepthSolver.java + + +// Targeting ../BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java + + + +// #endif //BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION + + +// Parsed from BulletSoftBody/btSoftBodySolvers.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFT_BODY_SOLVERS_H +// #define BT_SOFT_BODY_SOLVERS_H + +// #include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h" +// Targeting ../BulletSoftBody/btSoftBodyTriangleData.java + + +// Targeting ../BulletSoftBody/btSoftBodyLinkData.java + + +// Targeting ../BulletSoftBody/btSoftBodyVertexData.java + + +// Targeting ../BulletSoftBody/btVertexBufferDescriptor.java + + +// Targeting ../BulletSoftBody/btSoftBodySolver.java + + +// Targeting ../BulletSoftBody/btSoftBodySolverOutput.java + + + +// #endif // #ifndef BT_SOFT_BODY_SOLVERS_H + + +// Parsed from BulletSoftBody/btSoftMultiBodyDynamicsWorld.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H +// #define BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H + +// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" +// #include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h" +// #include "BulletSoftBody/btSoftBody.h" + +// #ifndef BT_SOFT_RIGID_DYNAMICS_WORLD_H +// Targeting ../BulletSoftBody/btSoftMultiBodyDynamicsWorld.java + + + +// #endif //BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H + + +// Parsed from BulletSoftBody/btDeformableBodySolver.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_BODY_SOLVERS_H +// #define BT_DEFORMABLE_BODY_SOLVERS_H + +// #include "btSoftBodySolvers.h" +// #include "btDeformableBackwardEulerObjective.h" +// #include "btDeformableMultiBodyDynamicsWorld.h" +// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" +// #include "btConjugateResidual.h" +// #include "btConjugateGradient.h" +// Targeting ../BulletSoftBody/btCollisionObjectWrapper.java + + +// Targeting ../BulletSoftBody/btDeformableBackwardEulerObjective.java + + +// Targeting ../BulletSoftBody/btDeformableBodySolver.java + + + +// #endif /* btDeformableBodySolver_h */ + + +// Parsed from BulletSoftBody/btDeformableMultiBodyConstraintSolver.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H +// #define BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H + +// #include "btDeformableBodySolver.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" +// Targeting ../BulletSoftBody/btDeformableMultiBodyConstraintSolver.java + + + +// #endif /* BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H */ + + +// Parsed from BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H +// #define BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H + +// #include "btSoftMultiBodyDynamicsWorld.h" +// #include "btDeformableLagrangianForce.h" +// #include "btDeformableMassSpringForce.h" +// #include "btDeformableBodySolver.h" +// #include "btDeformableMultiBodyConstraintSolver.h" +// #include "btSoftBodyHelpers.h" +// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" +// #include +// Targeting ../BulletSoftBody/btDeformableLagrangianForce.java + + +// Targeting ../BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java + + +// Targeting ../BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java + + +// Targeting ../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java + + + +// #endif //BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H + + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index fda4565d056..8bb03bc0a13 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -708,12 +708,27 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../LinearMath/btAlignedObjectArray_btVector3.java +// Targeting ../LinearMath/btAlignedObjectArray_bool.java + + +// Targeting ../LinearMath/btAlignedObjectArray_int.java // Targeting ../LinearMath/btAlignedObjectArray_btScalar.java +// Targeting ../LinearMath/btAlignedObjectArray_btVector3.java + + +// Targeting ../LinearMath/btAlignedObjectArray_btVector4.java + + +// Targeting ../LinearMath/btAlignedObjectArray_btMatrix3x3.java + + +// Targeting ../LinearMath/btAlignedObjectArray_btQuaternion.java + + // #endif //BT_OBJECT_ARRAY__ @@ -989,4 +1004,43 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // #endif //BT_DEFAULT_MOTION_STATE_H +// Parsed from LinearMath/btSpatialAlgebra.h + +/* +Copyright (c) 2003-2015 Erwin Coumans, Jakub Stepien + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**These spatial algebra classes are used for btMultiBody, +/**see BulletDynamics/Featherstone */ + +// #ifndef BT_SPATIAL_ALGEBRA_H +// #define BT_SPATIAL_ALGEBRA_H + +// #include "btMatrix3x3.h" +// Targeting ../LinearMath/btSpatialForceVector.java + + +// Targeting ../LinearMath/btSpatialMotionVector.java + + +// Targeting ../LinearMath/btSymmetricSpatialDyad.java + + +// Targeting ../LinearMath/btSpatialTransformationMatrix.java + + + +// #endif //BT_SPATIAL_ALGEBRA_H + + } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 7fb41577a7a..f72dfa10fb4 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -24,6 +24,7 @@ "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h", "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h", "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h", + "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h", "BulletCollision/CollisionDispatch/btCollisionObject.h", "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h", "BulletCollision/CollisionDispatch/btCollisionDispatcher.h", @@ -89,6 +90,12 @@ public void map(InfoMap infoMap) { .put(new Info("btDbvtProxy").skip()) .put(new Info("DBVT_BP_PROFILE").define(false)) .put(new Info("btDispatcher.h").linePatterns("class btRigidBody;").skip()) + .put(new Info("btPersistentManifoldData").cppText("#define btPersistentManifoldData btPersistentManifoldFloatData")) + .put(new Info("DEBUG_PERSISTENCY").define(false)) + .put(new Info("gContactDestroyedCallback").skip()) + .put(new Info("gContactProcessedCallback").skip()) + .put(new Info("gContactStartedCallback").skip()) + .put(new Info("gContactEndedCallback").skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index 94ed183cab9..e959e99da70 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -35,6 +35,12 @@ "BulletDynamics/Vehicle/btVehicleRaycaster.h", "BulletDynamics/Vehicle/btWheelInfo.h", "BulletDynamics/Vehicle/btRaycastVehicle.h", + "BulletDynamics/Featherstone/btMultiBodyJointFeedback.h", + "BulletDynamics/Featherstone/btMultiBodyLink.h", + "BulletDynamics/Featherstone/btMultiBody.h", + "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h", + "BulletDynamics/Featherstone/btMultiBodyConstraint.h", + "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h", }, link = "BulletDynamics" ) @@ -51,8 +57,7 @@ public void map(InfoMap infoMap) { .cppText("#define btRigidBodyData btRigidBodyFloatData")) .put(new Info("defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0") .define(false)) - .put(new Info("btAlignedObjectArray") - .pointerTypes("btAlignedObjectArray_btRigidBodyPointer")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btRigidBody")) .put(new Info("IN_PARALLELL_SOLVER").define(false)) .put(new Info("BT_BACKWARDS_COMPATIBLE_SERIALIZATION").define(true)) .put(new Info("btConstraintInfo1").skip()) @@ -100,6 +105,15 @@ public void map(InfoMap infoMap) { .cppText("#define btGearConstraintData btGearConstraintFloatData")) .put(new Info("btSingleConstraintRowSolver").skip()) .put(new Info("btRaycastVehicle::m_wheelInfo").skip()) + .put(new Info("btMultiBodyData") + .cppText("#define btMultiBodyData btMultiBodyFloatData")) + .put(new Info("btMultiBodyLinkData") + .cppText("#define btMultiBodyLinkData btMultiBodyLinkFloatData")) + .put(new Info("btMultiBodyLinkColliderData") + .cppText("#define btMultiBodyLinkColliderData btMultiBodyLinkColliderFloatData")) + .put(new Info("btMultiBodyConstraint::createConstraintRows").skip()) + .put(new Info("btMultiBodyJacobianData::m_solverBodyPool").skip()) + .put(new Info("btMultiBodyDynamicsWorld::getAnalyticsData").skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java new file mode 100644 index 00000000000..78715f32eb6 --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -0,0 +1,80 @@ +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.annotation.Cast; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; +import org.bytedeco.javacpp.FunctionPointer; +import org.bytedeco.javacpp.Pointer; + +@Properties( + inherit = BulletDynamics.class, + value = { + @Platform( + include = { + "LinearMath/btAlignedObjectArray.h", + "BulletSoftBody/btSparseSDF.h", + "BulletSoftBody/btSoftBody.h", + "BulletSoftBody/btSoftRigidDynamicsWorld.h", + "BulletSoftBody/btSoftBodyHelpers.h", + "BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h", + "BulletSoftBody/btSoftBodySolvers.h", + "BulletSoftBody/btSoftMultiBodyDynamicsWorld.h", + "BulletSoftBody/btDeformableBodySolver.h", + "BulletSoftBody/btDeformableMultiBodyConstraintSolver.h", + "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h", + }, + link = "BulletSoftBody" + ) + }, + target = "org.bytedeco.bullet.BulletSoftBody", + global = "org.bytedeco.bullet.global.BulletSoftBody" +) +public class BulletSoftBody implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + public void map(InfoMap infoMap) { + infoMap + .put(new Info("btSparseSdf<3>").pointerTypes("btSparseSdf_3")) + .put(new Info("btSparseSdf<3>::IntFrac").skip()) + .put(new Info("btSparseSdf<3>::Cell").skip()) + .put(new Info("btSparseSdf<3>::cells").skip()) + .put(new Info("btSoftBody::m_collisionDisabledObjects").skip()) + .put(new Info("btSoftBody::Cluster::m_nodes").skip()) + .put(new Info("btSoftBody::Cluster::m_leaf").skip()) + .put(new Info("btSoftBody::m_tetraScratches").skip()) + .put(new Info("btSoftBody::m_tetraScratchesTn").skip()) + .put(new Info("btSoftBody::m_deformableAnchors").skip()) + .put(new Info("btSoftBody::m_nodeRigidContacts").skip()) + .put(new Info("btSoftBody::m_faceRigidContacts").skip()) + .put(new Info("btSoftBody::m_faceNodeContacts").skip()) + .put(new Info("btSoftBody::m_renderNodesParents").skip()) + .put(new Info("btSoftBody::solveClusters").skip()) + .put(new Info("btSoftBody::m_fdbvnt").skip()) + .put(new Info("btSoftBody::updateNode").skip()) + .put(new Info("btSoftBody::Joint::eType").skip()) + .put(new Info("btSoftBody::Joint::eType::_").skip()) + .put(new Info("btSoftBody::Face::m_leaf").skip()) + .put(new Info("btSoftBody::Node::m_leaf").skip()) + .put(new Info("btSoftBody::Tetra::m_leaf").skip()) + .put(new Info("btSoftBody::AJoint::Type").skip()) + .put(new Info("btSoftBody::LJoint::Type").skip()) + .put(new Info("btSoftBody::CJoint::Type").skip()) + .put(new Info("btSoftBody::RayFromToCaster").skip()) + .put(new Info("btSoftBodyData").cppText("#define btSoftBodyData btSoftBodyFloatData")) + .put(new Info("SAFE_EPSILON").skip()) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody")) + .put(new Info("btSoftBodySolver::SolverTypes").enumerate()) + .put(new Info( + "btDeformableBodySolver::computeStep", + "btDeformableBodySolver::computeDescentStep" + ).skip()) + .put(new Info("btDeformableMultiBodyDynamicsWorld::setSolverCallback").skip()) + .put(new Info("btDeformableMultiBodyDynamicsWorld::rayTestSingle").skip()) + ; + } +} diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 6ef5f5c58ef..44b6f951ba5 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -26,6 +26,7 @@ "LinearMath/btQuickprof.h", "LinearMath/btMotionState.h", "LinearMath/btDefaultMotionState.h", + "LinearMath/btSpatialAlgebra.h", }, link = "LinearMath" ) @@ -83,8 +84,14 @@ public void map(InfoMap infoMap) { // btAlignedObjectArray.h .put(new Info("btAlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector3")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_bool")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_int")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btScalar")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector3")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector4")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btMatrix3x3")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btQuaternion")) ; } } diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 3162158be92..7a918a1e54b 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -5,4 +5,5 @@ exports org.bytedeco.bullet.LinearMath; exports org.bytedeco.bullet.BulletCollision; exports org.bytedeco.bullet.BulletDynamics; + exports org.bytedeco.bullet.BulletSoftBody; } From 38c103755b15e4751ec08be9b0def92d9d1dafd3 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 19 Feb 2022 12:36:18 +0800 Subject: [PATCH 12/81] Generate bindings for forward-declarted types --- .../BulletCollision/btCollisionAlgorithm.java | 14 +- .../btCollisionAlgorithmConstructionInfo.java | 25 +- .../btCollisionConfiguration.java | 19 +- .../BulletCollision/btCollisionResult.java | 22 - .../BulletCollision/btCompoundShapeChild.java | 2 + .../btConvexPenetrationDepthSolver.java | 13 +- .../BulletCollision/btConvexPolyhedron.java | 37 +- .../bullet/BulletCollision/btDbvntNode.java | 34 ++ .../bullet/BulletCollision/btDbvt.java | 219 ++++++- .../bullet/BulletCollision/btDbvtAabbMm.java | 83 +++ .../bullet/BulletCollision/btDbvtNode.java | 43 ++ .../bullet/BulletCollision/btElement.java | 36 ++ .../bullet/BulletCollision/btFace.java | 38 ++ .../btGjkEpaPenetrationDepthSolver.java | 41 ++ .../BulletCollision/btPoolAllocator.java | 21 - .../btSimplexSolverInterface.java | 49 ++ .../btSimulationIslandManager.java | 62 ++ .../btSubSimplexClosestResult.java | 47 ++ .../bullet/BulletCollision/btUnionFind.java | 56 ++ .../BulletCollision/btUsageBitfield.java | 44 ++ .../btVoronoiSimplexSolver.java | 78 ++- .../InplaceSolverIslandCallback.java | 24 - .../MultiBodyInplaceSolverIslandCallback.java | 23 - .../BulletDynamics/btActionInterface.java | 12 +- .../bullet/BulletDynamics/btAngularLimit.java | 80 +++ .../BulletDynamics/btJointFeedback.java | 41 ++ .../btMultiBodyConstraintSolver.java | 30 +- .../btSimulationIslandManager.java | 23 - .../bullet/BulletDynamics/btSolverBody.java | 102 ++++ .../BulletDynamics/btSolverConstraint.java | 71 +++ .../bullet/BulletDynamics/btSolverInfo.java | 23 - .../bullet/BulletDynamics/btStackAlloc.java | 23 - .../BulletDynamics/btTypedConstraint.java | 167 +++++- .../BulletDynamics/btTypedConstraintData.java | 55 ++ .../btTypedConstraintDoubleData.java | 57 ++ .../btTypedConstraintFloatData.java | 57 ++ ...rmableBodyInplaceSolverIslandCallback.java | 25 - .../MultiBodyInplaceSolverIslandCallback.java | 25 - .../btCPUVertexBufferDescriptor.java | 59 ++ .../btDeformableBackwardEulerObjective.java | 79 ++- .../btDeformableLagrangianForce.java | 64 +- .../btGjkEpaPenetrationDepthSolver.java | 25 - .../BulletSoftBody/btSoftBodyLinkData.java | 25 - .../btSoftBodyTriangleData.java | 26 - .../BulletSoftBody/btSoftBodyVertexData.java | 25 - .../btVertexBufferDescriptor.java | 41 +- .../btVoronoiSimplexSolver.java | 26 - .../bytedeco/bullet/LinearMath/btBlock.java | 35 ++ .../bullet/LinearMath/btPoolAllocator.java | 39 ++ .../bullet/LinearMath/btStackAlloc.java | 32 + .../bullet/global/BulletCollision.java | 553 +++++++++++++++++- .../bullet/global/BulletDynamics.java | 247 +++++++- .../bullet/global/BulletSoftBody.java | 129 +++- .../bytedeco/bullet/global/LinearMath.java | 65 ++ .../bullet/presets/BulletCollision.java | 22 + .../bullet/presets/BulletDynamics.java | 13 + .../bullet/presets/BulletSoftBody.java | 16 + .../bytedeco/bullet/presets/LinearMath.java | 2 + 58 files changed, 2888 insertions(+), 456 deletions(-) delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionResult.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btElement.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoolAllocator.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplexSolverInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimulationIslandManager.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubSimplexClosestResult.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUnionFind.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUsageBitfield.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJointFeedback.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManager.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btStackAlloc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintFloatData.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btGjkEpaPenetrationDepthSolver.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVoronoiSimplexSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java index e752417fa42..34640a27b01 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java @@ -13,10 +13,18 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +/**btCollisionAlgorithm is an collision interface that is compatible with the Broadphase and btDispatcher. + * It is persistent over frames */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btCollisionAlgorithm extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionAlgorithm() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btCollisionAlgorithm(Pointer p) { super(p); } + + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btAlignedObjectArray_bool manifoldArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java index eb999318b55..4af5c58a250 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java @@ -12,10 +12,29 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btCollisionAlgorithmConstructionInfo extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionAlgorithmConstructionInfo() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btCollisionAlgorithmConstructionInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCollisionAlgorithmConstructionInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCollisionAlgorithmConstructionInfo position(long position) { + return (btCollisionAlgorithmConstructionInfo)super.position(position); + } + @Override public btCollisionAlgorithmConstructionInfo getPointer(long i) { + return new btCollisionAlgorithmConstructionInfo((Pointer)this).offsetAddress(i); + } + + public btCollisionAlgorithmConstructionInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + public btCollisionAlgorithmConstructionInfo(btDispatcher dispatcher, int temp) { super((Pointer)null); allocate(dispatcher, temp); } + private native void allocate(btDispatcher dispatcher, int temp); + + public native btDispatcher m_dispatcher1(); public native btCollisionAlgorithmConstructionInfo m_dispatcher1(btDispatcher setter); + public native btPersistentManifold m_manifold(); public native btCollisionAlgorithmConstructionInfo m_manifold(btPersistentManifold setter); + + // int getDispatcherId(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java index 1e8899d7fae..88061089730 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java @@ -12,10 +12,23 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) + +/**btCollisionConfiguration allows to configure Bullet collision detection + * stack allocator size, default collision algorithms and persistent manifold pool size + * \todo: describe the meaning */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btCollisionConfiguration extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionConfiguration() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btCollisionConfiguration(Pointer p) { super(p); } + + + /**memory pools */ + public native btPoolAllocator getPersistentManifoldPool(); + + public native btPoolAllocator getCollisionAlgorithmPool(); + + public native btCollisionAlgorithmCreateFunc getCollisionAlgorithmCreateFunc(int proxyType0, int proxyType1); + + public native btCollisionAlgorithmCreateFunc getClosestPointsAlgorithmCreateFunc(int proxyType0, int proxyType1); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionResult.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionResult.java deleted file mode 100644 index 8fe2954082f..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionResult.java +++ /dev/null @@ -1,22 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletCollision; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; - -import static org.bytedeco.bullet.global.BulletCollision.*; - - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btCollisionResult extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionResult() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionResult(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java index 2e501d53f83..2980287d26f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.BulletCollision.*; +//class btOptimizedBvh; + @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btCompoundShapeChild extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java index a7ae07c0555..d33933dbc34 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java @@ -12,10 +12,17 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) + +/**ConvexPenetrationDepthSolver provides an interface for penetration depth calculation. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btConvexPenetrationDepthSolver extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btConvexPenetrationDepthSolver() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btConvexPenetrationDepthSolver(Pointer p) { super(p); } + + public native @Cast("bool") boolean calcPenDepth(@ByRef btSimplexSolverInterface simplexSolver, + @Const btConvexShape convexA, @Const btConvexShape convexB, + @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, + @ByRef btVector3 v, @ByRef btVector3 pa, @ByRef btVector3 pb, + btIDebugDraw debugDraw); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java index e6be63cc862..52be4eabd9e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java @@ -12,10 +12,41 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btConvexPolyhedron extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btConvexPolyhedron() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btConvexPolyhedron(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexPolyhedron(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btConvexPolyhedron position(long position) { + return (btConvexPolyhedron)super.position(position); + } + @Override public btConvexPolyhedron getPointer(long i) { + return new btConvexPolyhedron((Pointer)this).offsetAddress(i); + } + + + public btConvexPolyhedron() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @ByRef btAlignedObjectArray_btVector3 m_vertices(); public native btConvexPolyhedron m_vertices(btAlignedObjectArray_btVector3 setter); + + public native @ByRef btAlignedObjectArray_btVector3 m_uniqueEdges(); public native btConvexPolyhedron m_uniqueEdges(btAlignedObjectArray_btVector3 setter); + + public native @ByRef btVector3 m_localCenter(); public native btConvexPolyhedron m_localCenter(btVector3 setter); + public native @ByRef btVector3 m_extents(); public native btConvexPolyhedron m_extents(btVector3 setter); + public native @Cast("btScalar") float m_radius(); public native btConvexPolyhedron m_radius(float setter); + public native @ByRef btVector3 mC(); public native btConvexPolyhedron mC(btVector3 setter); + public native @ByRef btVector3 mE(); public native btConvexPolyhedron mE(btVector3 setter); + + public native void initialize(); + public native void initialize2(); + public native @Cast("bool") boolean testContainment(); + + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatPointer minProj, @Cast("btScalar*") @ByRef FloatPointer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef FloatBuffer minProj, @Cast("btScalar*") @ByRef FloatBuffer maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); + public native void project(@Const @ByRef btTransform trans, @Const @ByRef btVector3 dir, @Cast("btScalar*") @ByRef float[] minProj, @Cast("btScalar*") @ByRef float[] maxProj, @ByRef btVector3 witnesPtMin, @ByRef btVector3 witnesPtMax); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java new file mode 100644 index 00000000000..44c1154d25a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/* btDbv(normal)tNode */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDbvntNode extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvntNode(Pointer p) { super(p); } + + public native @ByRef @Cast("btDbvtVolume*") btDbvtAabbMm volume(); public native btDbvntNode volume(btDbvtAabbMm setter); + public native @ByRef btVector3 normal(); public native btDbvntNode normal(btVector3 setter); + public native @Cast("btScalar") float angle(); public native btDbvntNode angle(float setter); + public native @Cast("bool") boolean isleaf(); + public native @Cast("bool") boolean isinternal(); + public native btDbvntNode childs(int i); public native btDbvntNode childs(int i, btDbvntNode setter); + @MemberGetter public native @Cast("btDbvntNode**") PointerPointer childs(); + public native Pointer data(); public native btDbvntNode data(Pointer setter); + + public btDbvntNode(@Const btDbvtNode n) { super((Pointer)null); allocate(n); } + private native void allocate(@Const btDbvtNode n); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java index 86d60b67dd9..950983f4409 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java @@ -13,11 +13,222 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -//class btOptimizedBvh; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +/**The btDbvt class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes (aabb tree). + * This btDbvt is used for soft body collision detection and for the btDbvtBroadphase. It has a fast insert, remove and update of nodes. + * Unlike the btQuantizedBvh, nodes can be dynamically moved around, which allows for change in topology of the underlying data structure. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btDbvt extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btDbvt() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btDbvt(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDbvt(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDbvt position(long position) { + return (btDbvt)super.position(position); + } + @Override public btDbvt getPointer(long i) { + return new btDbvt((Pointer)this).offsetAddress(i); + } + + /* Stack element */ + @NoOffset public static class sStkNN extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkNN(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sStkNN(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public sStkNN position(long position) { + return (sStkNN)super.position(position); + } + @Override public sStkNN getPointer(long i) { + return new sStkNN((Pointer)this).offsetAddress(i); + } + + public native @Const btDbvtNode a(); public native sStkNN a(btDbvtNode setter); + public native @Const btDbvtNode b(); public native sStkNN b(btDbvtNode setter); + public sStkNN() { super((Pointer)null); allocate(); } + private native void allocate(); + public sStkNN(@Const btDbvtNode na, @Const btDbvtNode nb) { super((Pointer)null); allocate(na, nb); } + private native void allocate(@Const btDbvtNode na, @Const btDbvtNode nb); + } + @NoOffset public static class sStkNP extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkNP(Pointer p) { super(p); } + + public native @Const btDbvtNode node(); public native sStkNP node(btDbvtNode setter); + public native int mask(); public native sStkNP mask(int setter); + public sStkNP(@Const btDbvtNode n, @Cast("unsigned") int m) { super((Pointer)null); allocate(n, m); } + private native void allocate(@Const btDbvtNode n, @Cast("unsigned") int m); + } + @NoOffset public static class sStkNPS extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkNPS(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sStkNPS(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public sStkNPS position(long position) { + return (sStkNPS)super.position(position); + } + @Override public sStkNPS getPointer(long i) { + return new sStkNPS((Pointer)this).offsetAddress(i); + } + + public native @Const btDbvtNode node(); public native sStkNPS node(btDbvtNode setter); + public native int mask(); public native sStkNPS mask(int setter); + public native @Cast("btScalar") float value(); public native sStkNPS value(float setter); + public sStkNPS() { super((Pointer)null); allocate(); } + private native void allocate(); + public sStkNPS(@Const btDbvtNode n, @Cast("unsigned") int m, @Cast("btScalar") float v) { super((Pointer)null); allocate(n, m, v); } + private native void allocate(@Const btDbvtNode n, @Cast("unsigned") int m, @Cast("btScalar") float v); + } + @NoOffset public static class sStkCLN extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkCLN(Pointer p) { super(p); } + + public native @Const btDbvtNode node(); public native sStkCLN node(btDbvtNode setter); + public native btDbvtNode parent(); public native sStkCLN parent(btDbvtNode setter); + public sStkCLN(@Const btDbvtNode n, btDbvtNode p) { super((Pointer)null); allocate(n, p); } + private native void allocate(@Const btDbvtNode n, btDbvtNode p); + } + + @NoOffset public static class sStknNN extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStknNN(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sStknNN(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public sStknNN position(long position) { + return (sStknNN)super.position(position); + } + @Override public sStknNN getPointer(long i) { + return new sStknNN((Pointer)this).offsetAddress(i); + } + + public native @Const btDbvntNode a(); public native sStknNN a(btDbvntNode setter); + public native @Const btDbvntNode b(); public native sStknNN b(btDbvntNode setter); + public sStknNN() { super((Pointer)null); allocate(); } + private native void allocate(); + public sStknNN(@Const btDbvntNode na, @Const btDbvntNode nb) { super((Pointer)null); allocate(na, nb); } + private native void allocate(@Const btDbvntNode na, @Const btDbvntNode nb); + } + // Policies/Interfaces + + /* ICollide */ + public static class ICollide extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public ICollide() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public ICollide(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ICollide(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public ICollide position(long position) { + return (ICollide)super.position(position); + } + @Override public ICollide getPointer(long i) { + return new ICollide((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const btDbvtNode arg0, @Const btDbvtNode arg1); + public native void Process(@Const btDbvtNode arg0); + public native void Process(@Const btDbvtNode n, @Cast("btScalar") float arg1); + public native void Process(@Const btDbvntNode arg0, @Const btDbvntNode arg1); + public native @Cast("bool") boolean Descent(@Const btDbvtNode arg0); + public native @Cast("bool") boolean AllLeaves(@Const btDbvtNode arg0); + } + /* IWriter */ + public static class IWriter extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IWriter(Pointer p) { super(p); } + + public native void Prepare(@Const btDbvtNode root, int numnodes); + public native void WriteNode(@Const btDbvtNode arg0, int index, int parent, int child0, int child1); + public native void WriteLeaf(@Const btDbvtNode arg0, int index, int parent); + } + /* IClone */ + public static class IClone extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public IClone() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public IClone(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IClone(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public IClone position(long position) { + return (IClone)super.position(position); + } + @Override public IClone getPointer(long i) { + return new IClone((Pointer)this).offsetAddress(i); + } + + public native void CloneLeaf(btDbvtNode arg0); + } + + // Constants + /** enum btDbvt:: */ + public static final int + SIMPLE_STACKSIZE = 64, + DOUBLE_STACKSIZE = SIMPLE_STACKSIZE * 2; + + // Fields + public native btDbvtNode m_root(); public native btDbvt m_root(btDbvtNode setter); + public native btDbvtNode m_free(); public native btDbvt m_free(btDbvtNode setter); + public native int m_lkhd(); public native btDbvt m_lkhd(int setter); + public native int m_leaves(); public native btDbvt m_leaves(int setter); + public native @Cast("unsigned") int m_opath(); public native btDbvt m_opath(int setter); + + + + // Methods + public btDbvt() { super((Pointer)null); allocate(); } + private native void allocate(); + public native void clear(); + public native @Cast("bool") boolean empty(); + public native void optimizeBottomUp(); + public native void optimizeTopDown(int bu_treshold/*=128*/); + public native void optimizeTopDown(); + public native void optimizeIncremental(int passes); + public native btDbvtNode insert(@Cast("const btDbvtVolume*") @ByRef btDbvtAabbMm box, Pointer data); + public native void update(btDbvtNode leaf, int lookahead/*=-1*/); + public native void update(btDbvtNode leaf); + public native void update(btDbvtNode leaf, @Cast("btDbvtVolume*") @ByRef btDbvtAabbMm volume); + public native @Cast("bool") boolean update(btDbvtNode leaf, @Cast("btDbvtVolume*") @ByRef btDbvtAabbMm volume, @Const @ByRef btVector3 velocity, @Cast("btScalar") float margin); + public native @Cast("bool") boolean update(btDbvtNode leaf, @Cast("btDbvtVolume*") @ByRef btDbvtAabbMm volume, @Const @ByRef btVector3 velocity); + public native @Cast("bool") boolean update(btDbvtNode leaf, @Cast("btDbvtVolume*") @ByRef btDbvtAabbMm volume, @Cast("btScalar") float margin); + public native void remove(btDbvtNode leaf); + public native void write(IWriter iwriter); + public native void clone(@ByRef btDbvt dest, IClone iclone/*=0*/); + public native void clone(@ByRef btDbvt dest); + public static native int maxdepth(@Const btDbvtNode node); + public static native int countLeaves(@Const btDbvtNode node); + +// #if DBVT_ENABLE_BENCHMARK + public static native void benchmark(); +// #else +// #endif + // DBVT_IPOLICY must support ICollide policy/interface +// #if 0 +// #endif + + /**rayTest is a re-entrant ray test, and can be called in parallel as long as the btAlignedAlloc is thread-safe (uses locking etc) + * rayTest is slower than rayTestInternal, because it builds a local stack, using memory allocations, and it recomputes signs/rayDirectionInverses each time */ + /**rayTestInternal is faster than rayTest, because it uses a persistent stack (to reduce dynamic memory allocations to a minimum) and it uses precomputed signs/rayInverseDirections + * rayTestInternal is used by btDbvtBroadphase to accelerate world ray casts */ + + // Helpers + public static native int nearest(@Const IntPointer i, @Const sStkNPS a, @Cast("btScalar") float v, int l, int h); + public static native int nearest(@Const IntBuffer i, @Const sStkNPS a, @Cast("btScalar") float v, int l, int h); + public static native int nearest(@Const int[] i, @Const sStkNPS a, @Cast("btScalar") float v, int l, int h); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java new file mode 100644 index 00000000000..9077e3de9c6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java @@ -0,0 +1,83 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +// #endif + +// #ifndef DBVT_USE_TEMPLATE +// #endif + +// #ifndef DBVT_USE_MEMMOVE +// #endif + +// #ifndef DBVT_ENABLE_BENCHMARK +// #endif + +// #ifndef DBVT_SELECT_IMPL +// #endif + +// #ifndef DBVT_MERGE_IMPL +// #endif + +// #ifndef DBVT_INT0_IMPL +// #endif + +// +// Defaults volumes +// + +/* btDbvtAabbMm */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDbvtAabbMm extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvtAabbMm(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDbvtAabbMm(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDbvtAabbMm position(long position) { + return (btDbvtAabbMm)super.position(position); + } + @Override public btDbvtAabbMm getPointer(long i) { + return new btDbvtAabbMm((Pointer)this).offsetAddress(i); + } + + public btDbvtAabbMm() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @ByVal btVector3 Center(); + public native @ByVal btVector3 Lengths(); + public native @ByVal btVector3 Extents(); + public native @Const @ByRef btVector3 Mins(); + public native @Const @ByRef btVector3 Maxs(); + public static native @ByVal btDbvtAabbMm FromCE(@Const @ByRef btVector3 c, @Const @ByRef btVector3 e); + public static native @ByVal btDbvtAabbMm FromCR(@Const @ByRef btVector3 c, @Cast("btScalar") float r); + public static native @ByVal btDbvtAabbMm FromMM(@Const @ByRef btVector3 mi, @Const @ByRef btVector3 mx); + public static native @ByVal btDbvtAabbMm FromPoints(@Const btVector3 pts, int n); + public static native @ByVal btDbvtAabbMm FromPoints(@Cast("const btVector3**") PointerPointer ppts, int n); + public native void Expand(@Const @ByRef btVector3 e); + public native void SignedExpand(@Const @ByRef btVector3 e); + public native @Cast("bool") boolean Contain(@Const @ByRef btDbvtAabbMm a); + public native int Classify(@Const @ByRef btVector3 n, @Cast("btScalar") float o, int s); + public native @Cast("btScalar") float ProjectMinimum(@Const @ByRef btVector3 v, @Cast("unsigned") int signs); + + + + + + + + + + public native @ByRef btVector3 tMins(); + public native @ByRef btVector3 tMaxs(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java new file mode 100644 index 00000000000..a33f59917c0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/* btDbvtNode */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDbvtNode extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btDbvtNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDbvtNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvtNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btDbvtNode position(long position) { + return (btDbvtNode)super.position(position); + } + @Override public btDbvtNode getPointer(long i) { + return new btDbvtNode((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Cast("btDbvtVolume*") btDbvtAabbMm volume(); public native btDbvtNode volume(btDbvtAabbMm setter); + public native btDbvtNode parent(); public native btDbvtNode parent(btDbvtNode setter); + public native @Cast("bool") boolean isleaf(); + public native @Cast("bool") boolean isinternal(); + public native btDbvtNode childs(int i); public native btDbvtNode childs(int i, btDbvtNode setter); + @MemberGetter public native @Cast("btDbvtNode**") PointerPointer childs(); + public native Pointer data(); public native btDbvtNode data(Pointer setter); + public native int dataAsInt(); public native btDbvtNode dataAsInt(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btElement.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btElement.java new file mode 100644 index 00000000000..7d307cf50f7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btElement.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btElement extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btElement() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btElement(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btElement(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btElement position(long position) { + return (btElement)super.position(position); + } + @Override public btElement getPointer(long i) { + return new btElement((Pointer)this).offsetAddress(i); + } + + public native int m_id(); public native btElement m_id(int setter); + public native int m_sz(); public native btElement m_sz(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java new file mode 100644 index 00000000000..16780549af7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btFace extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btFace() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btFace(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btFace(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btFace position(long position) { + return (btFace)super.position(position); + } + @Override public btFace getPointer(long i) { + return new btFace((Pointer)this).offsetAddress(i); + } + + public native @ByRef btAlignedObjectArray_int m_indices(); public native btFace m_indices(btAlignedObjectArray_int setter); + // btAlignedObjectArray m_connectedFaces; + public native @Cast("btScalar") float m_plane(int i); public native btFace m_plane(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_plane(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java new file mode 100644 index 00000000000..560cb1d2958 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**EpaPenetrationDepthSolver uses the Expanding Polytope Algorithm to + * calculate the penetration depth between two convex shapes. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGjkEpaPenetrationDepthSolver extends btConvexPenetrationDepthSolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGjkEpaPenetrationDepthSolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGjkEpaPenetrationDepthSolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btGjkEpaPenetrationDepthSolver position(long position) { + return (btGjkEpaPenetrationDepthSolver)super.position(position); + } + @Override public btGjkEpaPenetrationDepthSolver getPointer(long i) { + return new btGjkEpaPenetrationDepthSolver((Pointer)this).offsetAddress(i); + } + + public btGjkEpaPenetrationDepthSolver() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean calcPenDepth(@ByRef btSimplexSolverInterface simplexSolver, + @Const btConvexShape pConvexA, @Const btConvexShape pConvexB, + @Const @ByRef btTransform transformA, @Const @ByRef btTransform transformB, + @ByRef btVector3 v, @ByRef btVector3 wWitnessOnA, @ByRef btVector3 wWitnessOnB, + btIDebugDraw debugDraw); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoolAllocator.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoolAllocator.java deleted file mode 100644 index 0bf580c64ba..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoolAllocator.java +++ /dev/null @@ -1,21 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletCollision; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; - -import static org.bytedeco.bullet.global.BulletCollision.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btPoolAllocator extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btPoolAllocator() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btPoolAllocator(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplexSolverInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplexSolverInterface.java new file mode 100644 index 00000000000..8ea2c18e9dd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplexSolverInterface.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +// #ifdef NO_VIRTUAL_INTERFACE +// #else + +/** btSimplexSolverInterface can incrementally calculate distance between origin and up to 4 vertices + * Used by GJK or Linear Casting. Can be implemented by the Johnson-algorithm or alternative approaches based on + * voronoi regions or barycentric coordinates */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSimplexSolverInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimplexSolverInterface(Pointer p) { super(p); } + + + public native void reset(); + + public native void addVertex(@Const @ByRef btVector3 w, @Const @ByRef btVector3 p, @Const @ByRef btVector3 q); + + public native @Cast("bool") boolean closest(@ByRef btVector3 v); + + public native @Cast("btScalar") float maxVertex(); + + public native @Cast("bool") boolean fullSimplex(); + + public native int getSimplex(btVector3 pBuf, btVector3 qBuf, btVector3 yBuf); + + public native @Cast("bool") boolean inSimplex(@Const @ByRef btVector3 w); + + public native void backup_closest(@ByRef btVector3 v); + + public native @Cast("bool") boolean emptySimplex(); + + public native void compute_points(@ByRef btVector3 p1, @ByRef btVector3 p2); + + public native int numVertices(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimulationIslandManager.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimulationIslandManager.java new file mode 100644 index 00000000000..3a83cc51cdc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimulationIslandManager.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**SimulationIslandManager creates and handles simulation islands, using btUnionFind */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSimulationIslandManager extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimulationIslandManager(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSimulationIslandManager(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSimulationIslandManager position(long position) { + return (btSimulationIslandManager)super.position(position); + } + @Override public btSimulationIslandManager getPointer(long i) { + return new btSimulationIslandManager((Pointer)this).offsetAddress(i); + } + + public btSimulationIslandManager() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void initUnionFind(int n); + + public native @ByRef btUnionFind getUnionFind(); + + public native void updateActivationState(btCollisionWorld colWorld, btDispatcher dispatcher); + public native void storeIslandActivationState(btCollisionWorld world); + + public native void findUnions(btDispatcher dispatcher, btCollisionWorld colWorld); + + public static class IslandCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IslandCallback(Pointer p) { super(p); } + + + public native void processIsland(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifolds, int numManifolds, int islandId); + public native void processIsland(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifolds, int numManifolds, int islandId); + } + + public native void buildAndProcessIslands(btDispatcher dispatcher, btCollisionWorld collisionWorld, IslandCallback callback); + + public native void buildIslands(btDispatcher dispatcher, btCollisionWorld colWorld); + + public native void processIslands(btDispatcher dispatcher, btCollisionWorld collisionWorld, IslandCallback callback); + + public native @Cast("bool") boolean getSplitIslands(); + public native void setSplitIslands(@Cast("bool") boolean doSplitIslands); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubSimplexClosestResult.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubSimplexClosestResult.java new file mode 100644 index 00000000000..4bcc76b326d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubSimplexClosestResult.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSubSimplexClosestResult extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSubSimplexClosestResult() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSubSimplexClosestResult(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSubSimplexClosestResult(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSubSimplexClosestResult position(long position) { + return (btSubSimplexClosestResult)super.position(position); + } + @Override public btSubSimplexClosestResult getPointer(long i) { + return new btSubSimplexClosestResult((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_closestPointOnSimplex(); public native btSubSimplexClosestResult m_closestPointOnSimplex(btVector3 setter); + //MASK for m_usedVertices + //stores the simplex vertex-usage, using the MASK, + // if m_usedVertices & MASK then the related vertex is used + public native @ByRef btUsageBitfield m_usedVertices(); public native btSubSimplexClosestResult m_usedVertices(btUsageBitfield setter); + public native @Cast("btScalar") float m_barycentricCoords(int i); public native btSubSimplexClosestResult m_barycentricCoords(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_barycentricCoords(); + public native @Cast("bool") boolean m_degenerate(); public native btSubSimplexClosestResult m_degenerate(boolean setter); + + public native void reset(); + public native @Cast("bool") boolean isValid(); + public native void setBarycentricCoordinates(@Cast("btScalar") float a/*=btScalar(0.)*/, @Cast("btScalar") float b/*=btScalar(0.)*/, @Cast("btScalar") float c/*=btScalar(0.)*/, @Cast("btScalar") float d/*=btScalar(0.)*/); + public native void setBarycentricCoordinates(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUnionFind.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUnionFind.java new file mode 100644 index 00000000000..192aa8e34de --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUnionFind.java @@ -0,0 +1,56 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**UnionFind calculates connected subsets */ +// Implements weighted Quick Union with path compression +// optimization: could use short ints instead of ints (halving memory, would limit the number of rigid bodies to 64k, sounds reasonable) +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btUnionFind extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btUnionFind(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btUnionFind(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btUnionFind position(long position) { + return (btUnionFind)super.position(position); + } + @Override public btUnionFind getPointer(long i) { + return new btUnionFind((Pointer)this).offsetAddress(i); + } + + public btUnionFind() { super((Pointer)null); allocate(); } + private native void allocate(); + + //this is a special operation, destroying the content of btUnionFind. + //it sorts the elements, based on island id, in order to make it easy to iterate over islands + public native void sortIslands(); + + public native void reset(int N); + + public native int getNumElements(); + public native @Cast("bool") boolean isRoot(int x); + + public native @ByRef btElement getElement(int index); + + public native @Name("allocate") void _allocate(int N); + public native void Free(); + + public native int find(int p, int q); + + public native void unite(int p, int q); + + public native int find(int x); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUsageBitfield.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUsageBitfield.java new file mode 100644 index 00000000000..b9fa6a7da12 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUsageBitfield.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +// #endif //BT_USE_DOUBLE_PRECISION + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btUsageBitfield extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btUsageBitfield(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btUsageBitfield(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btUsageBitfield position(long position) { + return (btUsageBitfield)super.position(position); + } + @Override public btUsageBitfield getPointer(long i) { + return new btUsageBitfield((Pointer)this).offsetAddress(i); + } + + public btUsageBitfield() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void reset(); + public native @Cast("unsigned short") @NoOffset short usedVertexA(); public native btUsageBitfield usedVertexA(short setter); + public native @Cast("unsigned short") @NoOffset short usedVertexB(); public native btUsageBitfield usedVertexB(short setter); + public native @Cast("unsigned short") @NoOffset short usedVertexC(); public native btUsageBitfield usedVertexC(short setter); + public native @Cast("unsigned short") @NoOffset short usedVertexD(); public native btUsageBitfield usedVertexD(short setter); + public native @Cast("unsigned short") @NoOffset short unused1(); public native btUsageBitfield unused1(short setter); + public native @Cast("unsigned short") @NoOffset short unused2(); public native btUsageBitfield unused2(short setter); + public native @Cast("unsigned short") @NoOffset short unused3(); public native btUsageBitfield unused3(short setter); + public native @Cast("unsigned short") @NoOffset short unused4(); public native btUsageBitfield unused4(short setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java index f5942182719..69b2fefa79d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java @@ -12,10 +12,80 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btVoronoiSimplexSolver extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btVoronoiSimplexSolver() { super((Pointer)null); } + +/** btVoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points simplex to the origin. + * Can be used with GJK, as an alternative to Johnson distance algorithm. */ +// #ifdef NO_VIRTUAL_INTERFACE +// #else +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btVoronoiSimplexSolver extends btSimplexSolverInterface { + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btVoronoiSimplexSolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btVoronoiSimplexSolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btVoronoiSimplexSolver position(long position) { + return (btVoronoiSimplexSolver)super.position(position); + } + @Override public btVoronoiSimplexSolver getPointer(long i) { + return new btVoronoiSimplexSolver((Pointer)this).offsetAddress(i); + } + + + public native int m_numVertices(); public native btVoronoiSimplexSolver m_numVertices(int setter); + + public native @ByRef btVector3 m_simplexVectorW(int i); public native btVoronoiSimplexSolver m_simplexVectorW(int i, btVector3 setter); + @MemberGetter public native btVector3 m_simplexVectorW(); + public native @ByRef btVector3 m_simplexPointsP(int i); public native btVoronoiSimplexSolver m_simplexPointsP(int i, btVector3 setter); + @MemberGetter public native btVector3 m_simplexPointsP(); + public native @ByRef btVector3 m_simplexPointsQ(int i); public native btVoronoiSimplexSolver m_simplexPointsQ(int i, btVector3 setter); + @MemberGetter public native btVector3 m_simplexPointsQ(); + + public native @ByRef btVector3 m_cachedP1(); public native btVoronoiSimplexSolver m_cachedP1(btVector3 setter); + public native @ByRef btVector3 m_cachedP2(); public native btVoronoiSimplexSolver m_cachedP2(btVector3 setter); + public native @ByRef btVector3 m_cachedV(); public native btVoronoiSimplexSolver m_cachedV(btVector3 setter); + public native @ByRef btVector3 m_lastW(); public native btVoronoiSimplexSolver m_lastW(btVector3 setter); + + public native @Cast("btScalar") float m_equalVertexThreshold(); public native btVoronoiSimplexSolver m_equalVertexThreshold(float setter); + public native @Cast("bool") boolean m_cachedValidClosest(); public native btVoronoiSimplexSolver m_cachedValidClosest(boolean setter); + + public native @ByRef btSubSimplexClosestResult m_cachedBC(); public native btVoronoiSimplexSolver m_cachedBC(btSubSimplexClosestResult setter); + + public native @Cast("bool") boolean m_needsUpdate(); public native btVoronoiSimplexSolver m_needsUpdate(boolean setter); + + public native void removeVertex(int index); + public native void reduceVertices(@Const @ByRef btUsageBitfield usedVerts); + public native @Cast("bool") boolean updateClosestVectorAndPoints(); + + public native @Cast("bool") boolean closestPtPointTetrahedron(@Const @ByRef btVector3 p, @Const @ByRef btVector3 a, @Const @ByRef btVector3 b, @Const @ByRef btVector3 c, @Const @ByRef btVector3 d, @ByRef btSubSimplexClosestResult finalResult); + public native int pointOutsideOfPlane(@Const @ByRef btVector3 p, @Const @ByRef btVector3 a, @Const @ByRef btVector3 b, @Const @ByRef btVector3 c, @Const @ByRef btVector3 d); + public native @Cast("bool") boolean closestPtPointTriangle(@Const @ByRef btVector3 p, @Const @ByRef btVector3 a, @Const @ByRef btVector3 b, @Const @ByRef btVector3 c, @ByRef btSubSimplexClosestResult result); + public btVoronoiSimplexSolver() { super((Pointer)null); allocate(); } + private native void allocate(); + public native void reset(); + + public native void addVertex(@Const @ByRef btVector3 w, @Const @ByRef btVector3 p, @Const @ByRef btVector3 q); + + public native void setEqualVertexThreshold(@Cast("btScalar") float threshold); + + public native @Cast("btScalar") float getEqualVertexThreshold(); + + public native @Cast("bool") boolean closest(@ByRef btVector3 v); + + public native @Cast("btScalar") float maxVertex(); + + public native @Cast("bool") boolean fullSimplex(); + + public native int getSimplex(btVector3 pBuf, btVector3 qBuf, btVector3 yBuf); + + public native @Cast("bool") boolean inSimplex(@Const @ByRef btVector3 w); + + public native void backup_closest(@ByRef btVector3 v); + + public native @Cast("bool") boolean emptySimplex(); + + public native void compute_points(@ByRef btVector3 p1, @ByRef btVector3 p2); + + public native int numVertices(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java deleted file mode 100644 index 8b1cff8d363..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java +++ /dev/null @@ -1,24 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletDynamics; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; - -import static org.bytedeco.bullet.global.BulletDynamics.*; - - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class InplaceSolverIslandCallback extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public InplaceSolverIslandCallback() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public InplaceSolverIslandCallback(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java deleted file mode 100644 index d64afe2626a..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java +++ /dev/null @@ -1,23 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletDynamics; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; - -import static org.bytedeco.bullet.global.BulletDynamics.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class MultiBodyInplaceSolverIslandCallback extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public MultiBodyInplaceSolverIslandCallback() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public MultiBodyInplaceSolverIslandCallback(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java index f8bfc1644bf..b90f2b48749 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java @@ -14,10 +14,16 @@ import static org.bytedeco.bullet.global.BulletDynamics.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) + +/**Basic interface to allow actions such as vehicles and characters to be updated inside a btDynamicsWorld */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) public class btActionInterface extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btActionInterface() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btActionInterface(Pointer p) { super(p); } + + + public native void updateAction(btCollisionWorld collisionWorld, @Cast("btScalar") float deltaTimeStep); + + public native void debugDraw(btIDebugDraw debugDrawer); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java new file mode 100644 index 00000000000..5a1c4bc726f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java @@ -0,0 +1,80 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btAngularLimit extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAngularLimit(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAngularLimit(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAngularLimit position(long position) { + return (btAngularLimit)super.position(position); + } + @Override public btAngularLimit getPointer(long i) { + return new btAngularLimit((Pointer)this).offsetAddress(i); + } + + /** Default constructor initializes limit as inactive, allowing free constraint movement */ + public btAngularLimit() { super((Pointer)null); allocate(); } + private native void allocate(); + + /** Sets all limit's parameters. + * When low > high limit becomes inactive. + * When high - low > 2PI limit is ineffective too becouse no angle can exceed the limit */ + public native void set(@Cast("btScalar") float low, @Cast("btScalar") float high, @Cast("btScalar") float _softness/*=0.9f*/, @Cast("btScalar") float _biasFactor/*=0.3f*/, @Cast("btScalar") float _relaxationFactor/*=1.0f*/); + public native void set(@Cast("btScalar") float low, @Cast("btScalar") float high); + + /** Checks conastaint angle against limit. If limit is active and the angle violates the limit + * correction is calculated. */ + public native void test(@Cast("const btScalar") float angle); + + /** Returns limit's softness */ + public native @Cast("btScalar") float getSoftness(); + + /** Returns limit's bias factor */ + public native @Cast("btScalar") float getBiasFactor(); + + /** Returns limit's relaxation factor */ + public native @Cast("btScalar") float getRelaxationFactor(); + + /** Returns correction value evaluated when test() was invoked */ + public native @Cast("btScalar") float getCorrection(); + + /** Returns sign value evaluated when test() was invoked */ + public native @Cast("btScalar") float getSign(); + + /** Gives half of the distance between min and max limit angle */ + public native @Cast("btScalar") float getHalfRange(); + + /** Returns true when the last test() invocation recognized limit violation */ + public native @Cast("bool") boolean isLimit(); + + /** Checks given angle against limit. If limit is active and angle doesn't fit it, the angle + * returned is modified so it equals to the limit closest to given angle. */ + public native void fit(@Cast("btScalar*") @ByRef FloatPointer angle); + public native void fit(@Cast("btScalar*") @ByRef FloatBuffer angle); + public native void fit(@Cast("btScalar*") @ByRef float[] angle); + + /** Returns correction value multiplied by sign value */ + public native @Cast("btScalar") float getError(); + + public native @Cast("btScalar") float getLow(); + + public native @Cast("btScalar") float getHigh(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJointFeedback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJointFeedback.java new file mode 100644 index 00000000000..462c3e7cadd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJointFeedback.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btJointFeedback extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btJointFeedback() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btJointFeedback(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btJointFeedback(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btJointFeedback position(long position) { + return (btJointFeedback)super.position(position); + } + @Override public btJointFeedback getPointer(long i) { + return new btJointFeedback((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_appliedForceBodyA(); public native btJointFeedback m_appliedForceBodyA(btVector3 setter); + public native @ByRef btVector3 m_appliedTorqueBodyA(); public native btJointFeedback m_appliedTorqueBodyA(btVector3 setter); + public native @ByRef btVector3 m_appliedForceBodyB(); public native btJointFeedback m_appliedForceBodyB(btVector3 setter); + public native @ByRef btVector3 m_appliedTorqueBodyB(); public native btJointFeedback m_appliedTorqueBodyB(btVector3 setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java index 89e28c60086..9179efac02f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java @@ -14,10 +14,32 @@ import static org.bytedeco.bullet.global.BulletDynamics.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btMultiBodyConstraintSolver extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btMultiBodyConstraintSolver() { super((Pointer)null); } + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyConstraintSolver extends btSequentialImpulseConstraintSolver { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiBodyConstraintSolver() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyConstraintSolver(long size) { super((Pointer)null); allocateArray(size); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btMultiBodyConstraintSolver(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiBodyConstraintSolver position(long position) { + return (btMultiBodyConstraintSolver)super.position(position); + } + @Override public btMultiBodyConstraintSolver getPointer(long i) { + return new btMultiBodyConstraintSolver((Pointer)this).offsetAddress(i); + } + + + /**this method should not be called, it was just used during porting/integration of Featherstone btMultiBody, providing backwards compatibility but no support for btMultiBodyConstraint (only contact constraints) */ + public native @Cast("btScalar") float solveGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + public native @Cast("btScalar") float solveGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + public native @Cast("btScalar") float solveGroupCacheFriendlyFinish(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Const @ByRef btContactSolverInfo infoGlobal); + public native @Cast("btScalar") float solveGroupCacheFriendlyFinish(@ByPtrPtr btCollisionObject bodies, int numBodies, @Const @ByRef btContactSolverInfo infoGlobal); + + public native void solveMultiBodyGroup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifold, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Cast("btMultiBodyConstraint**") PointerPointer multiBodyConstraints, int numMultiBodyConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); + public native void solveMultiBodyGroup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifold, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @ByPtrPtr btMultiBodyConstraint multiBodyConstraints, int numMultiBodyConstraints, @Const @ByRef btContactSolverInfo info, btIDebugDraw debugDrawer, btDispatcher dispatcher); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManager.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManager.java deleted file mode 100644 index dec071e1f3c..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManager.java +++ /dev/null @@ -1,23 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletDynamics; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; - -import static org.bytedeco.bullet.global.BulletDynamics.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btSimulationIslandManager extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btSimulationIslandManager() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSimulationIslandManager(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java new file mode 100644 index 00000000000..6819c1d8b8e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java @@ -0,0 +1,102 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif + +/**The btSolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolverBody extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSolverBody() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSolverBody(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverBody(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSolverBody position(long position) { + return (btSolverBody)super.position(position); + } + @Override public btSolverBody getPointer(long i) { + return new btSolverBody((Pointer)this).offsetAddress(i); + } + + public native @ByRef btTransform m_worldTransform(); public native btSolverBody m_worldTransform(btTransform setter); + public native @ByRef btVector3 m_deltaLinearVelocity(); public native btSolverBody m_deltaLinearVelocity(btVector3 setter); + public native @ByRef btVector3 m_deltaAngularVelocity(); public native btSolverBody m_deltaAngularVelocity(btVector3 setter); + public native @ByRef btVector3 m_angularFactor(); public native btSolverBody m_angularFactor(btVector3 setter); + public native @ByRef btVector3 m_linearFactor(); public native btSolverBody m_linearFactor(btVector3 setter); + public native @ByRef btVector3 m_invMass(); public native btSolverBody m_invMass(btVector3 setter); + public native @ByRef btVector3 m_pushVelocity(); public native btSolverBody m_pushVelocity(btVector3 setter); + public native @ByRef btVector3 m_turnVelocity(); public native btSolverBody m_turnVelocity(btVector3 setter); + public native @ByRef btVector3 m_linearVelocity(); public native btSolverBody m_linearVelocity(btVector3 setter); + public native @ByRef btVector3 m_angularVelocity(); public native btSolverBody m_angularVelocity(btVector3 setter); + public native @ByRef btVector3 m_externalForceImpulse(); public native btSolverBody m_externalForceImpulse(btVector3 setter); + public native @ByRef btVector3 m_externalTorqueImpulse(); public native btSolverBody m_externalTorqueImpulse(btVector3 setter); + + public native btRigidBody m_originalBody(); public native btSolverBody m_originalBody(btRigidBody setter); + public native void setWorldTransform(@Const @ByRef btTransform worldTransform); + + public native @Const @ByRef btTransform getWorldTransform(); + + public native void getVelocityInLocalPointNoDelta(@Const @ByRef btVector3 rel_pos, @ByRef btVector3 velocity); + + public native void getVelocityInLocalPointObsolete(@Const @ByRef btVector3 rel_pos, @ByRef btVector3 velocity); + + public native void getAngularVelocity(@ByRef btVector3 angVel); + + //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position + public native void applyImpulse(@Const @ByRef btVector3 linearComponent, @Const @ByRef btVector3 angularComponent, @Cast("const btScalar") float impulseMagnitude); + + public native void internalApplyPushImpulse(@Const @ByRef btVector3 linearComponent, @Const @ByRef btVector3 angularComponent, @Cast("btScalar") float impulseMagnitude); + + public native @Const @ByRef btVector3 getDeltaLinearVelocity(); + + public native @Const @ByRef btVector3 getDeltaAngularVelocity(); + + public native @Const @ByRef btVector3 getPushVelocity(); + + public native @Const @ByRef btVector3 getTurnVelocity(); + + //////////////////////////////////////////////// + /**some internal methods, don't use them */ + + public native @ByRef btVector3 internalGetDeltaLinearVelocity(); + + public native @ByRef btVector3 internalGetDeltaAngularVelocity(); + + public native @Const @ByRef btVector3 internalGetAngularFactor(); + + public native @Const @ByRef btVector3 internalGetInvMass(); + + public native void internalSetInvMass(@Const @ByRef btVector3 invMass); + + public native @ByRef btVector3 internalGetPushVelocity(); + + public native @ByRef btVector3 internalGetTurnVelocity(); + + public native void internalGetVelocityInLocalPointObsolete(@Const @ByRef btVector3 rel_pos, @ByRef btVector3 velocity); + + public native void internalGetAngularVelocity(@ByRef btVector3 angVel); + + //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position + public native void internalApplyImpulse(@Const @ByRef btVector3 linearComponent, @Const @ByRef btVector3 angularComponent, @Cast("const btScalar") float impulseMagnitude); + + public native void writebackVelocity(); + + public native void writebackVelocityAndTransform(@Cast("btScalar") float timeStep, @Cast("btScalar") float splitImpulseTurnErp); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java new file mode 100644 index 00000000000..f909623a154 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java @@ -0,0 +1,71 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolverConstraint extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSolverConstraint() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSolverConstraint(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverConstraint(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSolverConstraint position(long position) { + return (btSolverConstraint)super.position(position); + } + @Override public btSolverConstraint getPointer(long i) { + return new btSolverConstraint((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btVector3 m_relpos1CrossNormal(); public native btSolverConstraint m_relpos1CrossNormal(btVector3 setter); + public native @ByRef btVector3 m_contactNormal1(); public native btSolverConstraint m_contactNormal1(btVector3 setter); + + public native @ByRef btVector3 m_relpos2CrossNormal(); public native btSolverConstraint m_relpos2CrossNormal(btVector3 setter); + public native @ByRef btVector3 m_contactNormal2(); public native btSolverConstraint m_contactNormal2(btVector3 setter); //usually m_contactNormal2 == -m_contactNormal1, but not always + + public native @ByRef btVector3 m_angularComponentA(); public native btSolverConstraint m_angularComponentA(btVector3 setter); + public native @ByRef btVector3 m_angularComponentB(); public native btSolverConstraint m_angularComponentB(btVector3 setter); + + public native @Cast("btScalar") float m_appliedPushImpulse(); public native btSolverConstraint m_appliedPushImpulse(float setter); + public native @Cast("btScalar") float m_appliedImpulse(); public native btSolverConstraint m_appliedImpulse(float setter); + + public native @Cast("btScalar") float m_friction(); public native btSolverConstraint m_friction(float setter); + public native @Cast("btScalar") float m_jacDiagABInv(); public native btSolverConstraint m_jacDiagABInv(float setter); + public native @Cast("btScalar") float m_rhs(); public native btSolverConstraint m_rhs(float setter); + public native @Cast("btScalar") float m_cfm(); public native btSolverConstraint m_cfm(float setter); + + public native @Cast("btScalar") float m_lowerLimit(); public native btSolverConstraint m_lowerLimit(float setter); + public native @Cast("btScalar") float m_upperLimit(); public native btSolverConstraint m_upperLimit(float setter); + public native @Cast("btScalar") float m_rhsPenetration(); public native btSolverConstraint m_rhsPenetration(float setter); + public native Pointer m_originalContactPoint(); public native btSolverConstraint m_originalContactPoint(Pointer setter); + public native @Cast("btScalar") float m_unusedPadding4(); public native btSolverConstraint m_unusedPadding4(float setter); + public native int m_numRowsForNonContactConstraint(); public native btSolverConstraint m_numRowsForNonContactConstraint(int setter); + + public native int m_overrideNumSolverIterations(); public native btSolverConstraint m_overrideNumSolverIterations(int setter); + public native int m_frictionIndex(); public native btSolverConstraint m_frictionIndex(int setter); + public native int m_solverBodyIdA(); public native btSolverConstraint m_solverBodyIdA(int setter); + public native int m_solverBodyIdB(); public native btSolverConstraint m_solverBodyIdB(int setter); + + /** enum btSolverConstraint::btSolverConstraintType */ + public static final int + BT_SOLVER_CONTACT_1D = 0, + BT_SOLVER_FRICTION_1D = 1; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java deleted file mode 100644 index 96d3dd2d978..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java +++ /dev/null @@ -1,23 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletDynamics; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; - -import static org.bytedeco.bullet.global.BulletDynamics.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btSolverInfo extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btSolverInfo() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSolverInfo(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btStackAlloc.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btStackAlloc.java deleted file mode 100644 index db24874b2ba..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btStackAlloc.java +++ /dev/null @@ -1,23 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletDynamics; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; - -import static org.bytedeco.bullet.global.BulletDynamics.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btStackAlloc extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btStackAlloc() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btStackAlloc(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java index f0f27ff083a..eaa90fcc46d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java @@ -14,10 +14,169 @@ import static org.bytedeco.bullet.global.BulletDynamics.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btTypedConstraint extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btTypedConstraint() { super((Pointer)null); } + +/**TypedConstraint is the baseclass for Bullet constraints and vehicles */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btTypedConstraint extends btTypedObject { + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btTypedConstraint(Pointer p) { super(p); } + + + public static class btConstraintInfo1 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConstraintInfo1() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConstraintInfo1(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintInfo1(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConstraintInfo1 position(long position) { + return (btConstraintInfo1)super.position(position); + } + @Override public btConstraintInfo1 getPointer(long i) { + return new btConstraintInfo1((Pointer)this).offsetAddress(i); + } + + public native int m_numConstraintRows(); public native btConstraintInfo1 m_numConstraintRows(int setter); + public native int nub(); public native btConstraintInfo1 nub(int setter); + } + + public static native @ByRef btRigidBody getFixedBody(); + + public static class btConstraintInfo2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConstraintInfo2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConstraintInfo2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintInfo2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConstraintInfo2 position(long position) { + return (btConstraintInfo2)super.position(position); + } + @Override public btConstraintInfo2 getPointer(long i) { + return new btConstraintInfo2((Pointer)this).offsetAddress(i); + } + + // integrator parameters: frames per second (1/stepsize), default error + // reduction parameter (0..1). + public native @Cast("btScalar") float fps(); public native btConstraintInfo2 fps(float setter); + public native @Cast("btScalar") float erp(); public native btConstraintInfo2 erp(float setter); + + // for the first and second body, pointers to two (linear and angular) + // n*3 jacobian sub matrices, stored by rows. these matrices will have + // been initialized to 0 on entry. if the second body is zero then the + // J2xx pointers may be 0. + public native @Cast("btScalar*") FloatPointer m_J1linearAxis(); public native btConstraintInfo2 m_J1linearAxis(FloatPointer setter); + public native @Cast("btScalar*") FloatPointer m_J1angularAxis(); public native btConstraintInfo2 m_J1angularAxis(FloatPointer setter); + public native @Cast("btScalar*") FloatPointer m_J2linearAxis(); public native btConstraintInfo2 m_J2linearAxis(FloatPointer setter); + public native @Cast("btScalar*") FloatPointer m_J2angularAxis(); public native btConstraintInfo2 m_J2angularAxis(FloatPointer setter); + + // elements to jump from one row to the next in J's + public native int rowskip(); public native btConstraintInfo2 rowskip(int setter); + + // right hand sides of the equation J*v = c + cfm * lambda. cfm is the + // "constraint force mixing" vector. c is set to zero on entry, cfm is + // set to a constant value (typically very small or zero) value on entry. + public native @Cast("btScalar*") FloatPointer m_constraintError(); public native btConstraintInfo2 m_constraintError(FloatPointer setter); + public native @Cast("btScalar*") FloatPointer cfm(); public native btConstraintInfo2 cfm(FloatPointer setter); + + // lo and hi limits for variables (set to -/+ infinity on entry). + public native @Cast("btScalar*") FloatPointer m_lowerLimit(); public native btConstraintInfo2 m_lowerLimit(FloatPointer setter); + public native @Cast("btScalar*") FloatPointer m_upperLimit(); public native btConstraintInfo2 m_upperLimit(FloatPointer setter); + + // number of solver iterations + public native int m_numIterations(); public native btConstraintInfo2 m_numIterations(int setter); + + //damping of the velocity + public native @Cast("btScalar") float m_damping(); public native btConstraintInfo2 m_damping(float setter); + } + + public native int getOverrideNumSolverIterations(); + + /**override the number of constraint solver iterations used to solve this constraint + * -1 will use the default number of iterations, as specified in SolverInfo.m_numIterations */ + public native void setOverrideNumSolverIterations(int overideNumIterations); + + /**internal method used by the constraint solver, don't use them directly */ + public native void buildJacobian(); + + /**internal method used by the constraint solver, don't use them directly */ + + /**internal method used by the constraint solver, don't use them directly */ + public native void getInfo1(btConstraintInfo1 info); + + /**internal method used by the constraint solver, don't use them directly */ + public native void getInfo2(btConstraintInfo2 info); + + /**internal method used by the constraint solver, don't use them directly */ + public native void internalSetAppliedImpulse(@Cast("btScalar") float appliedImpulse); + /**internal method used by the constraint solver, don't use them directly */ + public native @Cast("btScalar") float internalGetAppliedImpulse(); + + public native @Cast("btScalar") float getBreakingImpulseThreshold(); + + public native void setBreakingImpulseThreshold(@Cast("btScalar") float threshold); + + public native @Cast("bool") boolean isEnabled(); + + public native void setEnabled(@Cast("bool") boolean enabled); + + /**internal method used by the constraint solver, don't use them directly */ + public native void solveConstraintObsolete(@ByRef btSolverBody arg0, @ByRef btSolverBody arg1, @Cast("btScalar") float arg2); + + public native @ByRef btRigidBody getRigidBodyA(); + public native @ByRef btRigidBody getRigidBodyB(); + + public native int getUserConstraintType(); + + public native void setUserConstraintType(int userConstraintType); + + public native void setUserConstraintId(int uid); + + public native int getUserConstraintId(); + + public native void setUserConstraintPtr(Pointer ptr); + + public native Pointer getUserConstraintPtr(); + + public native void setJointFeedback(btJointFeedback jointFeedback); + + public native btJointFeedback getJointFeedback(); + + public native int getUid(); + + public native @Cast("bool") boolean needsFeedback(); + + /**enableFeedback will allow to read the applied linear and angular impulse + * use getAppliedImpulse, getAppliedLinearImpulse and getAppliedAngularImpulse to read feedback information */ + public native void enableFeedback(@Cast("bool") boolean needsFeedback); + + /**getAppliedImpulse is an estimated total applied impulse. + * This feedback could be used to determine breaking constraints or playing sounds. */ + public native @Cast("btScalar") float getAppliedImpulse(); + + public native @Cast("btTypedConstraintType") int getConstraintType(); + + public native void setDbgDrawSize(@Cast("btScalar") float dbgDrawSize); + public native @Cast("btScalar") float getDbgDrawSize(); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("btScalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("btScalar") float value); + + /**return the local value of parameter */ + public native @Cast("btScalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("btScalar") float getParam(int num); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintData.java new file mode 100644 index 00000000000..c3833e12c6a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintData.java @@ -0,0 +1,55 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #ifdef BT_BACKWARDS_COMPATIBLE_SERIALIZATION +/**this structure is not used, except for loading pre-2.82 .bullet files */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btTypedConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTypedConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTypedConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTypedConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTypedConstraintData position(long position) { + return (btTypedConstraintData)super.position(position); + } + @Override public btTypedConstraintData getPointer(long i) { + return new btTypedConstraintData((Pointer)this).offsetAddress(i); + } + + public native btRigidBodyFloatData m_rbA(); public native btTypedConstraintData m_rbA(btRigidBodyFloatData setter); + public native btRigidBodyFloatData m_rbB(); public native btTypedConstraintData m_rbB(btRigidBodyFloatData setter); + public native @Cast("char*") BytePointer m_name(); public native btTypedConstraintData m_name(BytePointer setter); + + public native int m_objectType(); public native btTypedConstraintData m_objectType(int setter); + public native int m_userConstraintType(); public native btTypedConstraintData m_userConstraintType(int setter); + public native int m_userConstraintId(); public native btTypedConstraintData m_userConstraintId(int setter); + public native int m_needsFeedback(); public native btTypedConstraintData m_needsFeedback(int setter); + + public native float m_appliedImpulse(); public native btTypedConstraintData m_appliedImpulse(float setter); + public native float m_dbgDrawSize(); public native btTypedConstraintData m_dbgDrawSize(float setter); + + public native int m_disableCollisionsBetweenLinkedBodies(); public native btTypedConstraintData m_disableCollisionsBetweenLinkedBodies(int setter); + public native int m_overrideNumSolverIterations(); public native btTypedConstraintData m_overrideNumSolverIterations(int setter); + + public native float m_breakingImpulseThreshold(); public native btTypedConstraintData m_breakingImpulseThreshold(float setter); + public native int m_isEnabled(); public native btTypedConstraintData m_isEnabled(int setter); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintDoubleData.java new file mode 100644 index 00000000000..41fb2875015 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintDoubleData.java @@ -0,0 +1,57 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +// #endif //BACKWARDS_COMPATIBLE + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btTypedConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTypedConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTypedConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTypedConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTypedConstraintDoubleData position(long position) { + return (btTypedConstraintDoubleData)super.position(position); + } + @Override public btTypedConstraintDoubleData getPointer(long i) { + return new btTypedConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + public native btRigidBodyDoubleData m_rbA(); public native btTypedConstraintDoubleData m_rbA(btRigidBodyDoubleData setter); + public native btRigidBodyDoubleData m_rbB(); public native btTypedConstraintDoubleData m_rbB(btRigidBodyDoubleData setter); + public native @Cast("char*") BytePointer m_name(); public native btTypedConstraintDoubleData m_name(BytePointer setter); + + public native int m_objectType(); public native btTypedConstraintDoubleData m_objectType(int setter); + public native int m_userConstraintType(); public native btTypedConstraintDoubleData m_userConstraintType(int setter); + public native int m_userConstraintId(); public native btTypedConstraintDoubleData m_userConstraintId(int setter); + public native int m_needsFeedback(); public native btTypedConstraintDoubleData m_needsFeedback(int setter); + + public native double m_appliedImpulse(); public native btTypedConstraintDoubleData m_appliedImpulse(double setter); + public native double m_dbgDrawSize(); public native btTypedConstraintDoubleData m_dbgDrawSize(double setter); + + public native int m_disableCollisionsBetweenLinkedBodies(); public native btTypedConstraintDoubleData m_disableCollisionsBetweenLinkedBodies(int setter); + public native int m_overrideNumSolverIterations(); public native btTypedConstraintDoubleData m_overrideNumSolverIterations(int setter); + + public native double m_breakingImpulseThreshold(); public native btTypedConstraintDoubleData m_breakingImpulseThreshold(double setter); + public native int m_isEnabled(); public native btTypedConstraintDoubleData m_isEnabled(int setter); + public native @Cast("char") byte padding(int i); public native btTypedConstraintDoubleData padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer padding(); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintFloatData.java new file mode 100644 index 00000000000..d6f836b1f68 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintFloatData.java @@ -0,0 +1,57 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +// clang-format off + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btTypedConstraintFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTypedConstraintFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTypedConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTypedConstraintFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTypedConstraintFloatData position(long position) { + return (btTypedConstraintFloatData)super.position(position); + } + @Override public btTypedConstraintFloatData getPointer(long i) { + return new btTypedConstraintFloatData((Pointer)this).offsetAddress(i); + } + + public native btRigidBodyFloatData m_rbA(); public native btTypedConstraintFloatData m_rbA(btRigidBodyFloatData setter); + public native btRigidBodyFloatData m_rbB(); public native btTypedConstraintFloatData m_rbB(btRigidBodyFloatData setter); + public native @Cast("char*") BytePointer m_name(); public native btTypedConstraintFloatData m_name(BytePointer setter); + + public native int m_objectType(); public native btTypedConstraintFloatData m_objectType(int setter); + public native int m_userConstraintType(); public native btTypedConstraintFloatData m_userConstraintType(int setter); + public native int m_userConstraintId(); public native btTypedConstraintFloatData m_userConstraintId(int setter); + public native int m_needsFeedback(); public native btTypedConstraintFloatData m_needsFeedback(int setter); + + public native float m_appliedImpulse(); public native btTypedConstraintFloatData m_appliedImpulse(float setter); + public native float m_dbgDrawSize(); public native btTypedConstraintFloatData m_dbgDrawSize(float setter); + + public native int m_disableCollisionsBetweenLinkedBodies(); public native btTypedConstraintFloatData m_disableCollisionsBetweenLinkedBodies(int setter); + public native int m_overrideNumSolverIterations(); public native btTypedConstraintFloatData m_overrideNumSolverIterations(int setter); + + public native float m_breakingImpulseThreshold(); public native btTypedConstraintFloatData m_breakingImpulseThreshold(float setter); + public native int m_isEnabled(); public native btTypedConstraintFloatData m_isEnabled(int setter); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java deleted file mode 100644 index 3779e9ccf3f..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java +++ /dev/null @@ -1,25 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletSoftBody; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; - -import static org.bytedeco.bullet.global.BulletSoftBody.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class DeformableBodyInplaceSolverIslandCallback extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public DeformableBodyInplaceSolverIslandCallback() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public DeformableBodyInplaceSolverIslandCallback(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java deleted file mode 100644 index 2ccaf0772b2..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java +++ /dev/null @@ -1,25 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletSoftBody; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; - -import static org.bytedeco.bullet.global.BulletSoftBody.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class MultiBodyInplaceSolverIslandCallback extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public MultiBodyInplaceSolverIslandCallback() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public MultiBodyInplaceSolverIslandCallback(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java new file mode 100644 index 00000000000..f44f476bbc7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btCPUVertexBufferDescriptor extends btVertexBufferDescriptor { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCPUVertexBufferDescriptor(Pointer p) { super(p); } + + /** + * vertexBasePointer is pointer to beginning of the buffer. + * vertexOffset is the offset in floats to the first vertex. + * vertexStride is the stride in floats between vertices. + */ + public btCPUVertexBufferDescriptor(FloatPointer basePointer, int vertexOffset, int vertexStride) { super((Pointer)null); allocate(basePointer, vertexOffset, vertexStride); } + private native void allocate(FloatPointer basePointer, int vertexOffset, int vertexStride); + public btCPUVertexBufferDescriptor(FloatBuffer basePointer, int vertexOffset, int vertexStride) { super((Pointer)null); allocate(basePointer, vertexOffset, vertexStride); } + private native void allocate(FloatBuffer basePointer, int vertexOffset, int vertexStride); + public btCPUVertexBufferDescriptor(float[] basePointer, int vertexOffset, int vertexStride) { super((Pointer)null); allocate(basePointer, vertexOffset, vertexStride); } + private native void allocate(float[] basePointer, int vertexOffset, int vertexStride); + + /** + * vertexBasePointer is pointer to beginning of the buffer. + * vertexOffset is the offset in floats to the first vertex. + * vertexStride is the stride in floats between vertices. + */ + public btCPUVertexBufferDescriptor(FloatPointer basePointer, int vertexOffset, int vertexStride, int normalOffset, int normalStride) { super((Pointer)null); allocate(basePointer, vertexOffset, vertexStride, normalOffset, normalStride); } + private native void allocate(FloatPointer basePointer, int vertexOffset, int vertexStride, int normalOffset, int normalStride); + public btCPUVertexBufferDescriptor(FloatBuffer basePointer, int vertexOffset, int vertexStride, int normalOffset, int normalStride) { super((Pointer)null); allocate(basePointer, vertexOffset, vertexStride, normalOffset, normalStride); } + private native void allocate(FloatBuffer basePointer, int vertexOffset, int vertexStride, int normalOffset, int normalStride); + public btCPUVertexBufferDescriptor(float[] basePointer, int vertexOffset, int vertexStride, int normalOffset, int normalStride) { super((Pointer)null); allocate(basePointer, vertexOffset, vertexStride, normalOffset, normalStride); } + private native void allocate(float[] basePointer, int vertexOffset, int vertexStride, int normalOffset, int normalStride); + + /** + * Return the type of the vertex buffer descriptor. + */ + + + /** + * Return the base pointer in memory to the first vertex. + */ + public native FloatPointer getBasePointer(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java index 3fb0ea47f80..5e6ece957bb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java @@ -16,10 +16,83 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) public class btDeformableBackwardEulerObjective extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btDeformableBackwardEulerObjective() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btDeformableBackwardEulerObjective(Pointer p) { super(p); } + + public native @Cast("btScalar") float m_dt(); public native btDeformableBackwardEulerObjective m_dt(float setter); + + public native @ByRef btAlignedObjectArray_btSoftBody m_softBodies(); public native btDeformableBackwardEulerObjective m_softBodies(btAlignedObjectArray_btSoftBody setter); + + + @MemberGetter public native @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 m_backupVelocity(); + + public native @Cast("bool") boolean m_implicit(); public native btDeformableBackwardEulerObjective m_implicit(boolean setter); + + + + public btDeformableBackwardEulerObjective(@ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 backup_v) { super((Pointer)null); allocate(softBodies, backup_v); } + private native void allocate(@ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 backup_v); + + public native void initialize(); + + // compute the rhs for CG solve, i.e, add the dt scaled implicit force to residual + public native void computeResidual(@Cast("btScalar") float dt, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual); + + // add explicit force to the velocity + public native void applyExplicitForce(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 force); + + // apply force to velocity and optionally reset the force to zero + public native void applyForce(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 force, @Cast("bool") boolean setZero); + + // compute the norm of the residual + public native @Cast("btScalar") float computeNorm(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual); + + // compute one step of the solve (there is only one solve if the system is linear) + public native void computeStep(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual, @Cast("const btScalar") float dt); + + // perform A*x = b + public native void multiply(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 b); + + // set initial guess for CG solve + public native void initialGuess(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual); + + // reset data structure and reset dt + public native void reinitialize(@Cast("bool") boolean nodeUpdated, @Cast("btScalar") float dt); + + public native void setDt(@Cast("btScalar") float dt); + + // add friction force to residual + public native void applyDynamicFriction(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 r); + + // add dv to velocity + public native void updateVelocity(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv); + + //set constraints as projections + public native void setConstraints(@Const @ByRef btContactSolverInfo infoGlobal); + + // update the projections and project the residual + public native void project(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 r); + + // perform precondition M^(-1) x = b + public native void precondition(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 b); + + // reindex all the vertices + public native void updateId(); + + + + public native void setImplicit(@Cast("bool") boolean implicit); + + // Calculate the total potential energy in the system + public native @Cast("btScalar") float totalEnergy(@Cast("btScalar") float dt); + + public native void addLagrangeMultiplier(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 vec, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 extended_vec); + + public native void addLagrangeMultiplierRHS(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 m_dv, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 extended_residual); + + public native void calculateContactForce(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 rhs, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 f); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java index 01fa19734ff..4c36907ef64 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java @@ -16,10 +16,68 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) public class btDeformableLagrangianForce extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btDeformableLagrangianForce() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btDeformableLagrangianForce(Pointer p) { super(p); } + + public native @ByRef btAlignedObjectArray_btSoftBody m_softBodies(); public native btDeformableLagrangianForce m_softBodies(btAlignedObjectArray_btSoftBody setter); + + + // add all forces + public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 force); + + // add damping df + public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 df); + + // build diagonal of A matrix + public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 diagA); + + // add elastic df + public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 dx, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 df); + + // add all forces that are explicit in explicit solve + public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 force); + + // add all damping forces + public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 force); + + public native void addScaledHessian(@Cast("btScalar") float scale); + + public native @Cast("btDeformableLagrangianForceType") int getForceType(); + + public native void reinitialize(@Cast("bool") boolean nodeUpdated); + + // get number of nodes that have the force + public native int getNumNodes(); + + // add a soft body to be affected by the particular lagrangian force + public native void addSoftBody(btSoftBody psb); + + public native void removeSoftBody(btSoftBody psb); + + + + // Calculate the incremental deformable generated from the input dx + public native @ByVal btMatrix3x3 Ds(int id0, int id1, int id2, int id3, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 dx); + + // Calculate the incremental deformable generated from the current velocity + public native @ByVal btMatrix3x3 DsFromVelocity(@Const btSoftBody.Node n0, @Const btSoftBody.Node n1, @Const btSoftBody.Node n2, @Const btSoftBody.Node n3); + + // test for addScaledElasticForce function + public native void testDerivative(); + + // test for addScaledElasticForce function + public native void testHessian(); + + // + public native double totalElasticEnergy(@Cast("btScalar") float dt); + + // + public native double totalDampingEnergy(@Cast("btScalar") float dt); + + // total Energy takes dt as input because certain energies depend on dt + public native double totalEnergy(@Cast("btScalar") float dt); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btGjkEpaPenetrationDepthSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btGjkEpaPenetrationDepthSolver.java deleted file mode 100644 index afcce40af25..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btGjkEpaPenetrationDepthSolver.java +++ /dev/null @@ -1,25 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletSoftBody; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; - -import static org.bytedeco.bullet.global.BulletSoftBody.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btGjkEpaPenetrationDepthSolver extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btGjkEpaPenetrationDepthSolver() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btGjkEpaPenetrationDepthSolver(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java deleted file mode 100644 index 3adc54507e7..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java +++ /dev/null @@ -1,25 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletSoftBody; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; - -import static org.bytedeco.bullet.global.BulletSoftBody.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btSoftBodyLinkData extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btSoftBodyLinkData() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSoftBodyLinkData(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java deleted file mode 100644 index 3bd1e6152b6..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java +++ /dev/null @@ -1,26 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletSoftBody; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; - -import static org.bytedeco.bullet.global.BulletSoftBody.*; - - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btSoftBodyTriangleData extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btSoftBodyTriangleData() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSoftBodyTriangleData(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java deleted file mode 100644 index 5fd2c95ed13..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java +++ /dev/null @@ -1,25 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletSoftBody; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; - -import static org.bytedeco.bullet.global.BulletSoftBody.*; - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btSoftBodyVertexData extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btSoftBodyVertexData() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSoftBodyVertexData(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java index 8af3e3485c7..c04ce9a9965 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java @@ -16,10 +16,45 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) public class btVertexBufferDescriptor extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btVertexBufferDescriptor() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btVertexBufferDescriptor(Pointer p) { super(p); } + + /** enum btVertexBufferDescriptor::BufferTypes */ + public static final int + CPU_BUFFER = 0, + DX11_BUFFER = 1, + OPENGL_BUFFER = 2; + + public native @Cast("bool") boolean hasVertexPositions(); + + public native @Cast("bool") boolean hasNormals(); + + /** + * Return the type of the vertex buffer descriptor. + */ + public native @Cast("btVertexBufferDescriptor::BufferTypes") int getBufferType(); + + /** + * Return the vertex offset in floats from the base pointer. + */ + public native int getVertexOffset(); + + /** + * Return the vertex stride in number of floats between vertices. + */ + public native int getVertexStride(); + + /** + * Return the vertex offset in floats from the base pointer. + */ + public native int getNormalOffset(); + + /** + * Return the vertex stride in number of floats between vertices. + */ + public native int getNormalStride(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVoronoiSimplexSolver.java deleted file mode 100644 index 16102b985d9..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVoronoiSimplexSolver.java +++ /dev/null @@ -1,26 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletSoftBody; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; - -import static org.bytedeco.bullet.global.BulletSoftBody.*; - - -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btVoronoiSimplexSolver extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btVoronoiSimplexSolver() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btVoronoiSimplexSolver(Pointer p) { super(p); } -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java new file mode 100644 index 00000000000..a9c959a437f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btBlock class is an internal structure for the btStackAlloc memory allocator. */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btBlock extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btBlock() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBlock(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBlock(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btBlock position(long position) { + return (btBlock)super.position(position); + } + @Override public btBlock getPointer(long i) { + return new btBlock((Pointer)this).offsetAddress(i); + } + + public native btBlock previous(); public native btBlock previous(btBlock setter); + public native @Cast("unsigned char*") @Name("address") BytePointer _address(); public native btBlock _address(BytePointer setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java new file mode 100644 index 00000000000..e56184df81b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btPoolAllocator class allows to efficiently allocate a large pool of objects, instead of dynamically allocating them separately. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btPoolAllocator extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoolAllocator(Pointer p) { super(p); } + + public btPoolAllocator(int elemSize, int maxElements) { super((Pointer)null); allocate(elemSize, maxElements); } + private native void allocate(int elemSize, int maxElements); + + public native int getFreeCount(); + + public native int getUsedCount(); + + public native int getMaxCount(); + + public native @Name("allocate") Pointer _allocate(int size); + + public native @Cast("bool") boolean validPtr(Pointer ptr); + + public native void freeMemory(Pointer ptr); + + public native int getElementSize(); + + public native @Cast("unsigned char*") BytePointer getPoolAddress(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java new file mode 100644 index 00000000000..327318f6980 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java @@ -0,0 +1,32 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out) */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btStackAlloc extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btStackAlloc(Pointer p) { super(p); } + + public btStackAlloc(@Cast("unsigned int") int size) { super((Pointer)null); allocate(size); } + private native void allocate(@Cast("unsigned int") int size); + + public native void create(@Cast("unsigned int") int size); + public native void destroy(); + + public native int getAvailableMemory(); + + public native @Cast("unsigned char*") @Name("allocate") BytePointer _allocate(@Cast("unsigned int") int size); + public native btBlock beginBlock(); + public native void endBlock(btBlock block); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index 305eefbae81..1a68952c3c4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -15,6 +15,273 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision { static { Loader.load(); } +// Parsed from BulletCollision/BroadphaseCollision/btDbvt.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2007 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**btDbvt implementation by Nathanael Presson */ + +// #ifndef BT_DYNAMIC_BOUNDING_VOLUME_TREE_H +// #define BT_DYNAMIC_BOUNDING_VOLUME_TREE_H + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btAabbUtil2.h" +// +// Compile time configuration +// + +// Implementation profiles +public static final int DBVT_IMPL_GENERIC = 0; // Generic implementation +public static final int DBVT_IMPL_SSE = 1; // SSE + +// Template implementation of ICollide +// #ifdef _WIN32 +// #else +public static final int DBVT_USE_TEMPLATE = 0; +// #endif + +// Use only intrinsics instead of inline asm +public static final int DBVT_USE_INTRINSIC_SSE = 1; + +// Using memmov for collideOCL +public static final int DBVT_USE_MEMMOVE = 1; + +// Enable benchmarking code +public static final int DBVT_ENABLE_BENCHMARK = 0; + +// Inlining +// #define DBVT_INLINE SIMD_FORCE_INLINE + +// Specific methods implementation + +//SSE gives errors on a MSVC 7.1 +// #if defined(BT_USE_SSE) //&& defined (_WIN32) +// #else +public static final int DBVT_SELECT_IMPL = DBVT_IMPL_GENERIC; +public static final int DBVT_MERGE_IMPL = DBVT_IMPL_GENERIC; +public static final int DBVT_INT0_IMPL = DBVT_IMPL_GENERIC; +// #endif + +// #if (DBVT_SELECT_IMPL == DBVT_IMPL_SSE) || +// (DBVT_MERGE_IMPL == DBVT_IMPL_SSE) || +// (DBVT_INT0_IMPL == DBVT_IMPL_SSE) +// #include +// #endif + +// +// Auto config and checks +// + +// #if DBVT_USE_TEMPLATE +// #define DBVT_VIRTUAL +// #define DBVT_VIRTUAL_DTOR(a) +// #define DBVT_PREFIX template +// #define DBVT_IPOLICY T& policy +// #define DBVT_CHECKTYPE +// static const ICollide& typechecker = *(T*)1; +// (void)typechecker; +// #else +// #endif + +// #if DBVT_USE_MEMMOVE +// #if !defined(__CELLOS_LV2__) && !defined(__MWERKS__) +// #include +// #endif +// #include +// Targeting ../BulletCollision/btDbvtAabbMm.java + + + +// Types +// Targeting ../BulletCollision/btDbvtNode.java + + +// Targeting ../BulletCollision/btDbvntNode.java + + +// Targeting ../BulletCollision/btDbvt.java + + + +// +// Inline's +// + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// +public static native @Cast("bool") boolean Intersect(@Const @ByRef btDbvtAabbMm a, + @Const @ByRef btDbvtAabbMm b); + +// +public static native @Cast("bool") boolean Intersect(@Const @ByRef btDbvtAabbMm a, + @Const @ByRef btVector3 b); + +////////////////////////////////////// + +// +public static native @Cast("btScalar") float Proximity(@Const @ByRef btDbvtAabbMm a, + @Const @ByRef btDbvtAabbMm b); + +// +public static native int Select(@Const @ByRef btDbvtAabbMm o, + @Const @ByRef btDbvtAabbMm a, + @Const @ByRef btDbvtAabbMm b); + +// +public static native void Merge(@Const @ByRef btDbvtAabbMm a, + @Const @ByRef btDbvtAabbMm b, + @ByRef btDbvtAabbMm r); + +// +public static native @Cast("bool") boolean NotEqual(@Const @ByRef btDbvtAabbMm a, + @Const @ByRef btDbvtAabbMm b); + +// +// Inline's +// + +// + + +// + + +// + + +// + + +// + + + + + +// #if 0 +// #endif + + + +// + + + + +// + + +// + + +// + + +// + + +// +// PP Cleanup +// + +// #undef DBVT_USE_MEMMOVE +// #undef DBVT_USE_TEMPLATE +// #undef DBVT_VIRTUAL_DTOR +// #undef DBVT_VIRTUAL +// #undef DBVT_PREFIX +// #undef DBVT_IPOLICY +// #undef DBVT_CHECKTYPE +// #undef DBVT_IMPL_GENERIC +// #undef DBVT_IMPL_SSE +// #undef DBVT_USE_INTRINSIC_SSE +// #undef DBVT_SELECT_IMPL +// #undef DBVT_MERGE_IMPL +// #undef DBVT_INT0_IMPL + +// #endif + + +// Parsed from BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_ALGORITHM_H +// #define BT_COLLISION_ALGORITHM_H + +// #include "LinearMath/btScalar.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btCollisionObjectWrapper.java + + +// Targeting ../BulletCollision/btCollisionAlgorithmConstructionInfo.java + + +// Targeting ../BulletCollision/btCollisionAlgorithm.java + + + +// #endif //BT_COLLISION_ALGORITHM_H + + // Parsed from BulletCollision/BroadphaseCollision/btBroadphaseProxy.h /* @@ -98,9 +365,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // Targeting ../BulletCollision/btBroadphaseProxy.java -// Targeting ../BulletCollision/btCollisionAlgorithm.java - - // Targeting ../BulletCollision/btBroadphasePair.java @@ -133,12 +397,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #ifndef BT_DISPATCHER_H // #define BT_DISPATCHER_H // #include "LinearMath/btScalar.h" -// Targeting ../BulletCollision/btCollisionObjectWrapper.java - - -// Targeting ../BulletCollision/btPoolAllocator.java - - // Targeting ../BulletCollision/btDispatcherInfo.java @@ -478,6 +736,106 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #endif +// Parsed from BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMPLEX_SOLVER_INTERFACE_H +// #define BT_SIMPLEX_SOLVER_INTERFACE_H + +// #include "LinearMath/btVector3.h" + +public static native @MemberGetter int NO_VIRTUAL_INTERFACE(); +public static final int NO_VIRTUAL_INTERFACE = NO_VIRTUAL_INTERFACE(); +// Targeting ../BulletCollision/btSimplexSolverInterface.java + + +// #endif +// #endif //BT_SIMPLEX_SOLVER_INTERFACE_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_VORONOI_SIMPLEX_SOLVER_H +// #define BT_VORONOI_SIMPLEX_SOLVER_H + +// #include "btSimplexSolverInterface.h" + +public static final int VORONOI_SIMPLEX_MAX_VERTS = 5; + +/**disable next define, or use defaultCollisionConfiguration->getSimplexSolver()->setEqualVertexThreshold(0.f) to disable/configure */ +// #define BT_USE_EQUAL_VERTEX_THRESHOLD + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +public static final double VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD = 0.0001f; +// Targeting ../BulletCollision/btUsageBitfield.java + + +// Targeting ../BulletCollision/btSubSimplexClosestResult.java + + +// Targeting ../BulletCollision/btVoronoiSimplexSolver.java + + + +// #endif //BT_VORONOI_SIMPLEX_SOLVER_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_PENETRATION_DEPTH_H +// #define BT_CONVEX_PENETRATION_DEPTH_H +// #include "btSimplexSolverInterface.h" +// Targeting ../BulletCollision/btConvexPenetrationDepthSolver.java + + +// #endif //BT_CONVEX_PENETRATION_DEPTH_H + + // Parsed from BulletCollision/NarrowPhaseCollision/btManifoldPoint.h /* @@ -575,9 +933,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #include "LinearMath/btTransform.h" // #include "btManifoldPoint.h" // #include "LinearMath/btAlignedAllocator.h" -// Targeting ../BulletCollision/btCollisionResult.java - - /**maximum contact breaking and merging threshold */ public static native @Cast("btScalar") float gContactBreakingThreshold(); public static native void gContactBreakingThreshold(float setter); @@ -627,6 +982,61 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #endif //BT_PERSISTENT_MANIFOLD_H +// Parsed from BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +EPA Copyright (c) Ricardo Padrela 2006 + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_GJP_EPA_PENETRATION_DEPTH_H +// #define BT_GJP_EPA_PENETRATION_DEPTH_H + +// #include "btConvexPenetrationDepthSolver.h" +// Targeting ../BulletCollision/btGjkEpaPenetrationDepthSolver.java + + + +// #endif // BT_GJP_EPA_PENETRATION_DEPTH_H + + +// Parsed from BulletCollision/CollisionDispatch/btCollisionConfiguration.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_CONFIGURATION +// #define BT_COLLISION_CONFIGURATION +// Targeting ../BulletCollision/btCollisionConfiguration.java + + + +// #endif //BT_COLLISION_CONFIGURATION + + // Parsed from BulletCollision/CollisionDispatch/btCollisionObject.h /* @@ -701,9 +1111,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #define BT_COLLISION_CREATE_FUNC // #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btCollisionAlgorithmConstructionInfo.java - - // Targeting ../BulletCollision/btCollisionAlgorithmCreateFunc.java @@ -737,9 +1144,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btCollisionConfiguration.java - - // #include "btCollisionCreateFunc.h" @@ -967,20 +1371,81 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #define BT_DEFAULT_COLLISION_CONFIGURATION // #include "btCollisionConfiguration.h" -// Targeting ../BulletCollision/btVoronoiSimplexSolver.java +// Targeting ../BulletCollision/btDefaultCollisionConstructionInfo.java -// Targeting ../BulletCollision/btConvexPenetrationDepthSolver.java +// Targeting ../BulletCollision/btDefaultCollisionConfiguration.java -// Targeting ../BulletCollision/btDefaultCollisionConstructionInfo.java +// #endif //BT_DEFAULT_COLLISION_CONFIGURATION -// Targeting ../BulletCollision/btDefaultCollisionConfiguration.java +// Parsed from BulletCollision/CollisionDispatch/btSimulationIslandManager.h +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMULATION_ISLAND_MANAGER_H +// #define BT_SIMULATION_ISLAND_MANAGER_H + +// #include "BulletCollision/CollisionDispatch/btUnionFind.h" +// #include "btCollisionCreateFunc.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btCollisionObject.h" +// Targeting ../BulletCollision/btSimulationIslandManager.java + + + +// #endif //BT_SIMULATION_ISLAND_MANAGER_H + + +// Parsed from BulletCollision/CollisionDispatch/btUnionFind.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_UNION_FIND_H +// #define BT_UNION_FIND_H + +// #include "LinearMath/btAlignedObjectArray.h" + +public static final int USE_PATH_COMPRESSION = 1; + +/**see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406 */ +public static final int STATIC_SIMULATION_ISLAND_OPTIMIZATION = 1; +// Targeting ../BulletCollision/btElement.java -// #endif //BT_DEFAULT_COLLISION_CONFIGURATION + +// Targeting ../BulletCollision/btUnionFind.java + + + +// #endif //BT_UNION_FIND_H // Parsed from BulletCollision/CollisionShapes/btCollisionShape.h @@ -1055,6 +1520,42 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #endif //BT_CONVEX_SHAPE_INTERFACE1 +// Parsed from BulletCollision/CollisionShapes/btConvexPolyhedron.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef _BT_POLYHEDRAL_FEATURES_H +// #define _BT_POLYHEDRAL_FEATURES_H + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btAlignedObjectArray.h" + +public static final int TEST_INTERNAL_OBJECTS = 1; +// Targeting ../BulletCollision/btFace.java + + +// Targeting ../BulletCollision/btConvexPolyhedron.java + + + +// #endif //_BT_POLYHEDRAL_FEATURES_H + + // Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h /* @@ -1077,9 +1578,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #include "LinearMath/btMatrix3x3.h" // #include "btConvexInternalShape.h" -// Targeting ../BulletCollision/btConvexPolyhedron.java - - // Targeting ../BulletCollision/btPolyhedralConvexShape.java @@ -1827,9 +2325,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #include "LinearMath/btMatrix3x3.h" // #include "btCollisionMargin.h" // #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btDbvt.java - - // Targeting ../BulletCollision/btCompoundShapeChild.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index 420d6f6834e..109c2ac8528 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -64,6 +64,35 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #endif //BT_OBJECT_ARRAY__ +// Parsed from BulletDynamics/Dynamics/btActionInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef _BT_ACTION_INTERFACE_H +// #define _BT_ACTION_INTERFACE_H + +// #include "LinearMath/btScalar.h" +// #include "btRigidBody.h" +// Targeting ../BulletDynamics/btActionInterface.java + + + +// #endif //_BT_ACTION_INTERFACE_H + + // Parsed from BulletDynamics/Dynamics/btRigidBody.h /* @@ -88,9 +117,6 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #include "LinearMath/btTransform.h" // #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // #include "BulletCollision/CollisionDispatch/btCollisionObject.h" -// Targeting ../BulletDynamics/btTypedConstraint.java - - public static native @Cast("btScalar") float gDeactivationTime(); public static native void gDeactivationTime(float setter); public static native @Cast("bool") boolean gDisableDeactivation(); public static native void gDisableDeactivation(boolean setter); @@ -146,9 +172,6 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" // #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" -// Targeting ../BulletDynamics/btActionInterface.java - - // Targeting ../BulletDynamics/btInternalTickCallback.java @@ -248,12 +271,6 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #define BT_DISCRETE_DYNAMICS_WORLD_H // #include "btDynamicsWorld.h" -// Targeting ../BulletDynamics/btSimulationIslandManager.java - - -// Targeting ../BulletDynamics/InplaceSolverIslandCallback.java - - // #include "LinearMath/btAlignedObjectArray.h" // #include "LinearMath/btThreads.h" @@ -929,9 +946,6 @@ Added by Roman Ponomarev (rponom@gmail.com) // #define BT_CONSTRAINT_SOLVER_H // #include "LinearMath/btScalar.h" -// Targeting ../BulletDynamics/btStackAlloc.java - - /** btConstraintSolver provides solver interface */ /** enum btConstraintSolverType */ @@ -983,6 +997,171 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H +// Parsed from BulletDynamics/ConstraintSolver/btSolverConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOLVER_CONSTRAINT_H +// #define BT_SOLVER_CONSTRAINT_H +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btJacobianEntry.h" +// #include "LinearMath/btAlignedObjectArray.h" + +//#define NO_FRICTION_TANGENTIALS 1 +// #include "btSolverBody.h" +// Targeting ../BulletDynamics/btSolverConstraint.java + + + +// #endif //BT_SOLVER_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btSolverBody.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOLVER_BODY_H +// #define BT_SOLVER_BODY_H +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMatrix3x3.h" + +// #include "LinearMath/btAlignedAllocator.h" +// #include "LinearMath/btTransformUtil.h" + +/**Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision */ +// #ifdef BT_USE_SSE +// #endif // + +// #ifdef USE_SIMD + +// #else +// #define btSimdScalar btScalar +// Targeting ../BulletDynamics/btSolverBody.java + + + +// #endif //BT_SOLVER_BODY_H + + +// Parsed from BulletDynamics/ConstraintSolver/btTypedConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2010 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TYPED_CONSTRAINT_H +// #define BT_TYPED_CONSTRAINT_H + +// #include "LinearMath/btScalar.h" +// #include "btSolverConstraint.h" +// #include "BulletDynamics/Dynamics/btRigidBody.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btTypedConstraintData2 btTypedConstraintFloatData +public static final String btTypedConstraintDataName = "btTypedConstraintFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility +/** enum btTypedConstraintType */ +public static final int + POINT2POINT_CONSTRAINT_TYPE = 3, + HINGE_CONSTRAINT_TYPE = 4, + CONETWIST_CONSTRAINT_TYPE = 5, + D6_CONSTRAINT_TYPE = 6, + SLIDER_CONSTRAINT_TYPE = 7, + CONTACT_CONSTRAINT_TYPE = 8, + D6_SPRING_CONSTRAINT_TYPE = 9, + GEAR_CONSTRAINT_TYPE = 10, + FIXED_CONSTRAINT_TYPE = 11, + D6_SPRING_2_CONSTRAINT_TYPE = 12, + MAX_CONSTRAINT_TYPE = 13; + +/** enum btConstraintParams */ +public static final int + BT_CONSTRAINT_ERP = 1, + BT_CONSTRAINT_STOP_ERP = 2, + BT_CONSTRAINT_CFM = 3, + BT_CONSTRAINT_STOP_CFM = 4; + +// #if 1 +// #define btAssertConstrParams(_par) btAssert(_par) +// #else +// #define btAssertConstrParams(_par) +// Targeting ../BulletDynamics/btJointFeedback.java + + +// Targeting ../BulletDynamics/btTypedConstraint.java + + + +// returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the limits +// all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD_PI]) +public static native @Cast("btScalar") float btAdjustAngleToLimits(@Cast("btScalar") float angleInRadians, @Cast("btScalar") float angleLowerLimitInRadians, @Cast("btScalar") float angleUpperLimitInRadians); +// Targeting ../BulletDynamics/btTypedConstraintFloatData.java + + + + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ + +// #define BT_BACKWARDS_COMPATIBLE_SERIALIZATION +// Targeting ../BulletDynamics/btTypedConstraintData.java + + +// Targeting ../BulletDynamics/btTypedConstraintDoubleData.java + + + +// clang-format on + + +// Targeting ../BulletDynamics/btAngularLimit.java + + + +// #endif //BT_TYPED_CONSTRAINT_H + + // Parsed from BulletDynamics/Vehicle/btVehicleRaycaster.h /* @@ -1286,9 +1465,6 @@ Added by Roman Ponomarev (rponom@gmail.com) MULTIBODY_CONSTRAINT_FIXED = 9, MAX_MULTIBODY_CONSTRAINT_TYPE = 10; -// Targeting ../BulletDynamics/btSolverInfo.java - - // #include "btMultiBodySolverConstraint.h" // Targeting ../BulletDynamics/btMultiBodyJacobianData.java @@ -1325,16 +1501,43 @@ Added by Roman Ponomarev (rponom@gmail.com) // #include "BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h" // #define BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY -// Targeting ../BulletDynamics/btMultiBodyConstraintSolver.java +// Targeting ../BulletDynamics/btMultiBodyDynamicsWorld.java -// Targeting ../BulletDynamics/MultiBodyInplaceSolverIslandCallback.java +// #endif //BT_MULTIBODY_DYNAMICS_WORLD_H -// Targeting ../BulletDynamics/btMultiBodyDynamicsWorld.java +// Parsed from BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org -// #endif //BT_MULTIBODY_DYNAMICS_WORLD_H +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_CONSTRAINT_SOLVER_H +// #define BT_MULTIBODY_CONSTRAINT_SOLVER_H + +// #include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" +// #include "btMultiBodySolverConstraint.h" + +// #define DIRECTLY_UPDATE_VELOCITY_DURING_SOLVER_ITERATIONS + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodyConstraintSolver.java + + + +// #endif //BT_MULTIBODY_CONSTRAINT_SOLVER_H } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index 2b4db8fb307..40d1d7a5bd8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -243,12 +243,6 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #define BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION // #include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" -// Targeting ../BulletSoftBody/btVoronoiSimplexSolver.java - - -// Targeting ../BulletSoftBody/btGjkEpaPenetrationDepthSolver.java - - // Targeting ../BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java @@ -277,18 +271,6 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #define BT_SOFT_BODY_SOLVERS_H // #include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h" -// Targeting ../BulletSoftBody/btSoftBodyTriangleData.java - - -// Targeting ../BulletSoftBody/btSoftBodyLinkData.java - - -// Targeting ../BulletSoftBody/btSoftBodyVertexData.java - - -// Targeting ../BulletSoftBody/btVertexBufferDescriptor.java - - // Targeting ../BulletSoftBody/btSoftBodySolver.java @@ -361,9 +343,6 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // Targeting ../BulletSoftBody/btCollisionObjectWrapper.java -// Targeting ../BulletSoftBody/btDeformableBackwardEulerObjective.java - - // Targeting ../BulletSoftBody/btDeformableBodySolver.java @@ -428,20 +407,118 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #include "btSoftBodyHelpers.h" // #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" // #include -// Targeting ../BulletSoftBody/btDeformableLagrangianForce.java +// Targeting ../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java -// Targeting ../BulletSoftBody/MultiBodyInplaceSolverIslandCallback.java +// #endif //BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H -// Targeting ../BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java +// Parsed from BulletSoftBody/btSoftBodySolverVertexBuffer.h -// Targeting ../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ -// #endif //BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H +// #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H +// #define BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H +// Targeting ../BulletSoftBody/btVertexBufferDescriptor.java + + +// Targeting ../BulletSoftBody/btCPUVertexBufferDescriptor.java + + + +// #endif // #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H + + +// Parsed from BulletSoftBody/btDeformableBackwardEulerObjective.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_BACKWARD_EULER_OBJECTIVE_H +// #define BT_BACKWARD_EULER_OBJECTIVE_H +//#include "btConjugateGradient.h" +// #include "btDeformableLagrangianForce.h" +// #include "btDeformableMassSpringForce.h" +// #include "btDeformableGravityForce.h" +// #include "btDeformableCorotatedForce.h" +// #include "btDeformableMousePickingForce.h" +// #include "btDeformableLinearElasticityForce.h" +// #include "btDeformableNeoHookeanForce.h" +// #include "btDeformableContactProjection.h" +// #include "btPreconditioner.h" +// #include "btDeformableMultiBodyDynamicsWorld.h" +// #include "LinearMath/btQuickprof.h" +// Targeting ../BulletSoftBody/btDeformableBackwardEulerObjective.java + + + +// #endif /* btBackwardEulerObjective_h */ + + +// Parsed from BulletSoftBody/btDeformableLagrangianForce.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_LAGRANGIAN_FORCE_H +// #define BT_DEFORMABLE_LAGRANGIAN_FORCE_H + +// #include "btSoftBody.h" +// #include +// #include + +/** enum btDeformableLagrangianForceType */ +public static final int + BT_GRAVITY_FORCE = 1, + BT_MASSSPRING_FORCE = 2, + BT_COROTATED_FORCE = 3, + BT_NEOHOOKEAN_FORCE = 4, + BT_LINEAR_ELASTICITY_FORCE = 5, + BT_MOUSE_PICKING_FORCE = 6; + +public static native double randomDouble(double low, double high); +// Targeting ../BulletSoftBody/btDeformableLagrangianForce.java + + +// #endif /* BT_DEFORMABLE_LAGRANGIAN_FORCE */ } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index 8bb03bc0a13..03dd7732703 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -1043,4 +1043,69 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // #endif //BT_SPATIAL_ALGEBRA_H +// Parsed from LinearMath/btPoolAllocator.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef _BT_POOL_ALLOCATOR_H +// #define _BT_POOL_ALLOCATOR_H + +// #include "btScalar.h" +// #include "btAlignedAllocator.h" +// #include "btThreads.h" +// Targeting ../LinearMath/btPoolAllocator.java + + + +// #endif //_BT_POOL_ALLOCATOR_H + + +// Parsed from LinearMath/btStackAlloc.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +StackAlloc extracted from GJK-EPA collision solver by Nathanael Presson +Nov.2006 +*/ + +// #ifndef BT_STACK_ALLOC +// #define BT_STACK_ALLOC + +// #include "btScalar.h" //for btAssert +// #include "btAlignedAllocator.h" +// Targeting ../LinearMath/btBlock.java + + +// Targeting ../LinearMath/btStackAlloc.java + + + +// #endif //BT_STACK_ALLOC + + } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index f72dfa10fb4..c6c285cf339 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -13,6 +13,8 @@ value = { @Platform( include = { + "BulletCollision/BroadphaseCollision/btDbvt.h", + "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h", "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h", "BulletCollision/BroadphaseCollision/btDispatcher.h", "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h", @@ -22,9 +24,14 @@ "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h", "BulletCollision/BroadphaseCollision/btAxisSweep3.h", "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h", + "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h", + "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h", + "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h", "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h", "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h", "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h", + "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h", + "BulletCollision/CollisionDispatch/btCollisionConfiguration.h", "BulletCollision/CollisionDispatch/btCollisionObject.h", "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h", "BulletCollision/CollisionDispatch/btCollisionDispatcher.h", @@ -33,8 +40,11 @@ "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h", + "BulletCollision/CollisionDispatch/btSimulationIslandManager.h", + "BulletCollision/CollisionDispatch/btUnionFind.h", "BulletCollision/CollisionShapes/btCollisionShape.h", "BulletCollision/CollisionShapes/btConvexShape.h", + "BulletCollision/CollisionShapes/btConvexPolyhedron.h", "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h", "BulletCollision/CollisionShapes/btConvexInternalShape.h", "BulletCollision/CollisionShapes/btBoxShape.h", @@ -91,11 +101,23 @@ public void map(InfoMap infoMap) { .put(new Info("DBVT_BP_PROFILE").define(false)) .put(new Info("btDispatcher.h").linePatterns("class btRigidBody;").skip()) .put(new Info("btPersistentManifoldData").cppText("#define btPersistentManifoldData btPersistentManifoldFloatData")) + .put(new Info("btPersistentManifold.h").linePatterns("struct btCollisionResult;").skip()) .put(new Info("DEBUG_PERSISTENCY").define(false)) .put(new Info("gContactDestroyedCallback").skip()) .put(new Info("gContactProcessedCallback").skip()) .put(new Info("gContactStartedCallback").skip()) .put(new Info("gContactEndedCallback").skip()) + .put(new Info("NO_VIRTUAL_INTERFACE").define(false)) + .put(new Info("btConvexPolyhedron::m_faces").skip()) + .put(new Info("btDbvt::m_stkStack").skip()) + .put(new Info("btDbvt::extractLeaves").skip()) + .put(new Info("btDbvt::rayTestInternal").skip()) + .put(new Info("btDbvt::allocate").skip()) + .put(new Info("DBVT_PREFIX").skip()) + .put(new Info("DBVT_IPOLICY").skip()) + .put(new Info("DBVT_INLINE").cppTypes().annotations()) + .put(new Info("DBVT_CHECKTYPE").skip()) + .put(new Info("BT_DECLARE_STACK_ONLY_OBJECT").cppText("#define BT_DECLARE_STACK_ONLY_OBJECT")) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index e959e99da70..f4c70369b07 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -14,6 +14,7 @@ @Platform( include = { "LinearMath/btAlignedObjectArray.h", + "BulletDynamics/Dynamics/btActionInterface.h", "BulletDynamics/Dynamics/btRigidBody.h", "BulletDynamics/Dynamics/btDynamicsWorld.h", "BulletDynamics/ConstraintSolver/btContactSolverInfo.h", @@ -32,6 +33,9 @@ "BulletDynamics/ConstraintSolver/btFixedConstraint.h", "BulletDynamics/ConstraintSolver/btConstraintSolver.h", "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h", + "BulletDynamics/ConstraintSolver/btSolverConstraint.h", + "BulletDynamics/ConstraintSolver/btSolverBody.h", + "BulletDynamics/ConstraintSolver/btTypedConstraint.h", "BulletDynamics/Vehicle/btVehicleRaycaster.h", "BulletDynamics/Vehicle/btWheelInfo.h", "BulletDynamics/Vehicle/btRaycastVehicle.h", @@ -41,6 +45,7 @@ "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h", "BulletDynamics/Featherstone/btMultiBodyConstraint.h", "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h", + "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h", }, link = "BulletDynamics" ) @@ -114,6 +119,14 @@ public void map(InfoMap infoMap) { .put(new Info("btMultiBodyConstraint::createConstraintRows").skip()) .put(new Info("btMultiBodyJacobianData::m_solverBodyPool").skip()) .put(new Info("btMultiBodyDynamicsWorld::getAnalyticsData").skip()) + .put(new Info("InplaceSolverIslandCallback").skip()) + .put(new Info("MultiBodyInplaceSolverIslandCallback").skip()) + .put(new Info("DeformableBodyInplaceSolverIslandCallback").skip()) + .put(new Info("btSolverInfo").skip()) + .put(new Info("USE_SIMD").define(false)) + .put(new Info("btSimdScalar").cppText("#define btSimdScalar btScalar")) + .put(new Info("btTypedConstraintData2").cppText("#define btTypedConstraintData2 btTypedConstraintFloatData")) + .put(new Info("btConstraintArray").skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 78715f32eb6..87e66f4421f 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -27,6 +27,9 @@ "BulletSoftBody/btDeformableBodySolver.h", "BulletSoftBody/btDeformableMultiBodyConstraintSolver.h", "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h", + "BulletSoftBody/btSoftBodySolverVertexBuffer.h", + "BulletSoftBody/btDeformableBackwardEulerObjective.h", + "BulletSoftBody/btDeformableLagrangianForce.h", }, link = "BulletSoftBody" ) @@ -75,6 +78,19 @@ public void map(InfoMap infoMap) { ).skip()) .put(new Info("btDeformableMultiBodyDynamicsWorld::setSolverCallback").skip()) .put(new Info("btDeformableMultiBodyDynamicsWorld::rayTestSingle").skip()) + .put(new Info("btCPUVertexBufferDescriptor::getBufferType").skip()) + .put(new Info("btSoftBodyVertexData").skip()) + .put(new Info("btSoftBodyTriangleData").skip()) + .put(new Info("btSoftBodyLinkData").skip()) + .put(new Info("btDeformableBackwardEulerObjective::m_lf").skip()) + .put(new Info("btDeformableBackwardEulerObjective::m_nodes").skip()) + .put(new Info("btDeformableBackwardEulerObjective::getIndices").skip()) + .put(new Info("btDeformableBackwardEulerObjective::m_preconditioner").skip()) + .put(new Info("btDeformableBackwardEulerObjective::m_massPreconditioner").skip()) + .put(new Info("btDeformableBackwardEulerObjective::m_KKTPreconditioner").skip()) + .put(new Info("btDeformableBackwardEulerObjective::m_projection").skip()) + .put(new Info("btDeformableLagrangianForce::m_nodes").skip()) + .put(new Info("btDeformableLagrangianForce::setIndices").skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 44b6f951ba5..f1712dbb133 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -27,6 +27,8 @@ "LinearMath/btMotionState.h", "LinearMath/btDefaultMotionState.h", "LinearMath/btSpatialAlgebra.h", + "LinearMath/btPoolAllocator.h", + "LinearMath/btStackAlloc.h", }, link = "LinearMath" ) From b62f36ab5372549711ac5035e4ebdbbe608c85e0 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 19 Feb 2022 13:21:54 +0800 Subject: [PATCH 13/81] Bindings for multithreaded bullet's solvers --- .../btCollisionDispatcherMt.java | 31 +++ .../BulletDynamics/btBatchedConstraints.java | 72 ++++++ .../btConstraintSolverPoolMt.java | 65 ++++++ .../btDiscreteDynamicsWorldMt.java | 47 ++++ ...btSequentialImpulseConstraintSolverMt.java | 159 +++++++++++++ .../btSimulationIslandManagerMt.java | 105 +++++++++ .../LinearMath/btAlignedObjectArray_char.java | 86 +++++++ .../bullet/global/BulletCollision.java | 29 +++ .../bullet/global/BulletDynamics.java | 210 +++++++++++++++--- .../bytedeco/bullet/global/LinearMath.java | 3 + .../bullet/presets/BulletCollision.java | 1 + .../bullet/presets/BulletDynamics.java | 16 +- .../bytedeco/bullet/presets/LinearMath.java | 1 + 13 files changed, 787 insertions(+), 38 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcherMt.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolverPoolMt.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcherMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcherMt.java new file mode 100644 index 00000000000..7286a440839 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcherMt.java @@ -0,0 +1,31 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionDispatcherMt extends btCollisionDispatcher { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionDispatcherMt(Pointer p) { super(p); } + + public btCollisionDispatcherMt(btCollisionConfiguration config, int grainSize/*=40*/) { super((Pointer)null); allocate(config, grainSize); } + private native void allocate(btCollisionConfiguration config, int grainSize/*=40*/); + public btCollisionDispatcherMt(btCollisionConfiguration config) { super((Pointer)null); allocate(config); } + private native void allocate(btCollisionConfiguration config); + + public native btPersistentManifold getNewManifold(@Const btCollisionObject body0, @Const btCollisionObject body1); + public native void releaseManifold(btPersistentManifold manifold); + + public native void dispatchAllCollisionPairs(btOverlappingPairCache pairCache, @Const @ByRef btDispatcherInfo info, btDispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java new file mode 100644 index 00000000000..5a6353c0246 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java @@ -0,0 +1,72 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btBatchedConstraints extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBatchedConstraints(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBatchedConstraints(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBatchedConstraints position(long position) { + return (btBatchedConstraints)super.position(position); + } + @Override public btBatchedConstraints getPointer(long i) { + return new btBatchedConstraints((Pointer)this).offsetAddress(i); + } + + /** enum btBatchedConstraints::BatchingMethod */ + public static final int + BATCHING_METHOD_SPATIAL_GRID_2D = 0, + BATCHING_METHOD_SPATIAL_GRID_3D = 1, + BATCHING_METHOD_COUNT = 2; + @NoOffset public static class Range extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Range(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Range(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Range position(long position) { + return (Range)super.position(position); + } + @Override public Range getPointer(long i) { + return new Range((Pointer)this).offsetAddress(i); + } + + public native int begin(); public native Range begin(int setter); + public native int end(); public native Range end(int setter); + + public Range() { super((Pointer)null); allocate(); } + private native void allocate(); + public Range(int _beg, int _end) { super((Pointer)null); allocate(_beg, _end); } + private native void allocate(int _beg, int _end); + } + + public native @ByRef btAlignedObjectArray_int m_constraintIndices(); public native btBatchedConstraints m_constraintIndices(btAlignedObjectArray_int setter); + // each batch is a range of indices in the m_constraintIndices array + // each phase is range of indices in the m_batches array + public native @ByRef btAlignedObjectArray_char m_phaseGrainSize(); public native btBatchedConstraints m_phaseGrainSize(btAlignedObjectArray_char setter); // max grain size for each phase + public native @ByRef btAlignedObjectArray_int m_phaseOrder(); public native btBatchedConstraints m_phaseOrder(btAlignedObjectArray_int setter); // phases can be done in any order, so we can randomize the order here + public native btIDebugDraw m_debugDrawer(); public native btBatchedConstraints m_debugDrawer(btIDebugDraw setter); + + public static native @Cast("bool") boolean s_debugDrawBatches(); public static native void s_debugDrawBatches(boolean setter); + + public btBatchedConstraints() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolverPoolMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolverPoolMt.java new file mode 100644 index 00000000000..36301f9f79c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolverPoolMt.java @@ -0,0 +1,65 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** + * btConstraintSolverPoolMt - masquerades as a constraint solver, but really it is a threadsafe pool of them. + * + * Each solver in the pool is protected by a mutex. When solveGroup is called from a thread, + * the pool looks for a solver that isn't being used by another thread, locks it, and dispatches the + * call to the solver. + * So long as there are at least as many solvers as there are hardware threads, it should never need to + * spin wait. + * */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btConstraintSolverPoolMt extends btConstraintSolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConstraintSolverPoolMt(Pointer p) { super(p); } + + // create the solvers for me + public btConstraintSolverPoolMt(int numSolvers) { super((Pointer)null); allocate(numSolvers); } + private native void allocate(int numSolvers); + + // pass in fully constructed solvers (destructor will delete them) + public btConstraintSolverPoolMt(@Cast("btConstraintSolver**") PointerPointer solvers, int numSolvers) { super((Pointer)null); allocate(solvers, numSolvers); } + private native void allocate(@Cast("btConstraintSolver**") PointerPointer solvers, int numSolvers); + public btConstraintSolverPoolMt(@ByPtrPtr btConstraintSolver solvers, int numSolvers) { super((Pointer)null); allocate(solvers, numSolvers); } + private native void allocate(@ByPtrPtr btConstraintSolver solvers, int numSolvers); + + /**solve a group of constraints */ + public native @Cast("btScalar") float solveGroup(@Cast("btCollisionObject**") PointerPointer bodies, + int numBodies, + @Cast("btPersistentManifold**") PointerPointer manifolds, + int numManifolds, + @Cast("btTypedConstraint**") PointerPointer constraints, + int numConstraints, + @Const @ByRef btContactSolverInfo info, + btIDebugDraw debugDrawer, + btDispatcher dispatcher); + public native @Cast("btScalar") float solveGroup(@ByPtrPtr btCollisionObject bodies, + int numBodies, + @ByPtrPtr btPersistentManifold manifolds, + int numManifolds, + @ByPtrPtr btTypedConstraint constraints, + int numConstraints, + @Const @ByRef btContactSolverInfo info, + btIDebugDraw debugDrawer, + btDispatcher dispatcher); + + public native void reset(); + public native @Cast("btConstraintSolverType") int getSolverType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java new file mode 100644 index 00000000000..11095ff7ae6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** + * btDiscreteDynamicsWorldMt -- a version of DiscreteDynamicsWorld with some minor changes to support + * solving simulation islands on multiple threads. + * + * Should function exactly like btDiscreteDynamicsWorld. + * Also 3 methods that iterate over all of the rigidbodies can run in parallel: + * - predictUnconstraintMotion + * - integrateTransforms + * - createPredictiveContacts + * */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btDiscreteDynamicsWorldMt extends btDiscreteDynamicsWorld { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDiscreteDynamicsWorldMt(Pointer p) { super(p); } + + + public btDiscreteDynamicsWorldMt(btDispatcher dispatcher, + btBroadphaseInterface pairCache, + btConstraintSolverPoolMt solverPool, + btConstraintSolver constraintSolverMt, + btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, solverPool, constraintSolverMt, collisionConfiguration); } + private native void allocate(btDispatcher dispatcher, + btBroadphaseInterface pairCache, + btConstraintSolverPoolMt solverPool, + btConstraintSolver constraintSolverMt, + btCollisionConfiguration collisionConfiguration); + + public native int stepSimulation(@Cast("btScalar") float timeStep, int maxSubSteps, @Cast("btScalar") float fixedTimeStep); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java new file mode 100644 index 00000000000..f5874bca158 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java @@ -0,0 +1,159 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** + * btSequentialImpulseConstraintSolverMt + * + * A multithreaded variant of the sequential impulse constraint solver. The constraints to be solved are grouped into + * batches and phases where each batch of constraints within a given phase can be solved in parallel with the rest. + * Ideally we want as few phases as possible, and each phase should have many batches, and all of the batches should + * have about the same number of constraints. + * This method works best on a large island of many constraints. + * + * Supports all of the features of the normal sequential impulse solver such as: + * - split penetration impulse + * - rolling friction + * - interleaving constraints + * - warmstarting + * - 2 friction directions + * - randomized constraint ordering + * - early termination when leastSquaresResidualThreshold is satisfied + * + * When the SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS flag is enabled, unlike the normal SequentialImpulse solver, + * the rolling friction is interleaved as well. + * Interleaving the contact penetration constraints with friction reduces the number of parallel loops that need to be done, + * which reduces threading overhead so it can be a performance win, however, it does seem to produce a less stable simulation, + * at least on stacks of blocks. + * + * When the SOLVER_RANDMIZE_ORDER flag is enabled, the ordering of phases, and the ordering of constraints within each batch + * is randomized, however it does not swap constraints between batches. + * This is to avoid regenerating the batches for each solver iteration which would be quite costly in performance. + * + * Note that a non-zero leastSquaresResidualThreshold could possibly affect the determinism of the simulation + * if the task scheduler's parallelSum operation is non-deterministic. The parallelSum operation can be non-deterministic + * because floating point addition is not associative due to rounding errors. + * The task scheduler can and should ensure that the result of any parallelSum operation is deterministic. + * */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSequentialImpulseConstraintSolverMt extends btSequentialImpulseConstraintSolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSequentialImpulseConstraintSolverMt(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSequentialImpulseConstraintSolverMt(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSequentialImpulseConstraintSolverMt position(long position) { + return (btSequentialImpulseConstraintSolverMt)super.position(position); + } + @Override public btSequentialImpulseConstraintSolverMt getPointer(long i) { + return new btSequentialImpulseConstraintSolverMt((Pointer)this).offsetAddress(i); + } + + public native void solveGroupCacheFriendlySplitImpulseIterations(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifoldPtr, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo infoGlobal, btIDebugDraw debugDrawer); + public native void solveGroupCacheFriendlySplitImpulseIterations(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifoldPtr, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo infoGlobal, btIDebugDraw debugDrawer); + public native @Cast("btScalar") float solveSingleIteration(int iteration, @Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifoldPtr, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo infoGlobal, btIDebugDraw debugDrawer); + public native @Cast("btScalar") float solveSingleIteration(int iteration, @ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifoldPtr, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo infoGlobal, btIDebugDraw debugDrawer); + public native @Cast("btScalar") float solveGroupCacheFriendlySetup(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifoldPtr, int numManifolds, @Cast("btTypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef btContactSolverInfo infoGlobal, btIDebugDraw debugDrawer); + public native @Cast("btScalar") float solveGroupCacheFriendlySetup(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifoldPtr, int numManifolds, @ByPtrPtr btTypedConstraint constraints, int numConstraints, @Const @ByRef btContactSolverInfo infoGlobal, btIDebugDraw debugDrawer); + public native @Cast("btScalar") float solveGroupCacheFriendlyFinish(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Const @ByRef btContactSolverInfo infoGlobal); + public native @Cast("btScalar") float solveGroupCacheFriendlyFinish(@ByPtrPtr btCollisionObject bodies, int numBodies, @Const @ByRef btContactSolverInfo infoGlobal); + + // temp struct used to collect info from persistent manifolds into a cache-friendly struct using multiple threads + public static class btContactManifoldCachedInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btContactManifoldCachedInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactManifoldCachedInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactManifoldCachedInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btContactManifoldCachedInfo position(long position) { + return (btContactManifoldCachedInfo)super.position(position); + } + @Override public btContactManifoldCachedInfo getPointer(long i) { + return new btContactManifoldCachedInfo((Pointer)this).offsetAddress(i); + } + + @MemberGetter public static native int MAX_NUM_CONTACT_POINTS(); + public static final int MAX_NUM_CONTACT_POINTS = MAX_NUM_CONTACT_POINTS(); + + public native int numTouchingContacts(); public native btContactManifoldCachedInfo numTouchingContacts(int setter); + public native int solverBodyIds(int i); public native btContactManifoldCachedInfo solverBodyIds(int i, int setter); + @MemberGetter public native IntPointer solverBodyIds(); + public native int contactIndex(); public native btContactManifoldCachedInfo contactIndex(int setter); + public native int rollingFrictionIndex(); public native btContactManifoldCachedInfo rollingFrictionIndex(int setter); + public native @Cast("bool") boolean contactHasRollingFriction(int i); public native btContactManifoldCachedInfo contactHasRollingFriction(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer contactHasRollingFriction(); + public native btManifoldPoint contactPoints(int i); public native btContactManifoldCachedInfo contactPoints(int i, btManifoldPoint setter); + @MemberGetter public native @Cast("btManifoldPoint**") PointerPointer contactPoints(); + } + // temp struct used for setting up joint constraints in parallel + public static class JointParams extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public JointParams() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public JointParams(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public JointParams(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public JointParams position(long position) { + return (JointParams)super.position(position); + } + @Override public JointParams getPointer(long i) { + return new JointParams((Pointer)this).offsetAddress(i); + } + + public native int m_solverConstraint(); public native JointParams m_solverConstraint(int setter); + public native int m_solverBodyA(); public native JointParams m_solverBodyA(int setter); + public native int m_solverBodyB(); public native JointParams m_solverBodyB(int setter); + } + public native void internalInitMultipleJoints(@Cast("btTypedConstraint**") PointerPointer constraints, int iBegin, int iEnd); + public native void internalInitMultipleJoints(@ByPtrPtr btTypedConstraint constraints, int iBegin, int iEnd); + + + // parameters to control batching + public static native @Cast("bool") boolean s_allowNestedParallelForLoops(); public static native void s_allowNestedParallelForLoops(boolean setter); // whether to allow nested parallel operations + public static native int s_minimumContactManifoldsForBatching(); public static native void s_minimumContactManifoldsForBatching(int setter); // don't even try to batch if fewer manifolds than this + public static native @Cast("btBatchedConstraints::BatchingMethod") int s_contactBatchingMethod(); public static native void s_contactBatchingMethod(int setter); + public static native @Cast("btBatchedConstraints::BatchingMethod") int s_jointBatchingMethod(); public static native void s_jointBatchingMethod(int setter); + public static native int s_minBatchSize(); public static native void s_minBatchSize(int setter); // desired number of constraints per batch + public static native int s_maxBatchSize(); public static native void s_maxBatchSize(int setter); + + public btSequentialImpulseConstraintSolverMt() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("btScalar") float resolveMultipleJointConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd, int iteration); + public native @Cast("btScalar") float resolveMultipleContactConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleContactSplitPenetrationImpulseConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleContactFrictionConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleContactRollingFrictionConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleContactConstraintsInterleaved(@Const @ByRef btAlignedObjectArray_int contactIndices, int batchBegin, int batchEnd); + + public native void internalCollectContactManifoldCachedInfo(btContactManifoldCachedInfo cachedInfoArray, @Cast("btPersistentManifold**") PointerPointer manifoldPtr, int numManifolds, @Const @ByRef btContactSolverInfo infoGlobal); + public native void internalCollectContactManifoldCachedInfo(btContactManifoldCachedInfo cachedInfoArray, @ByPtrPtr btPersistentManifold manifoldPtr, int numManifolds, @Const @ByRef btContactSolverInfo infoGlobal); + public native void internalAllocContactConstraints(@Const btContactManifoldCachedInfo cachedInfoArray, int numManifolds); + public native void internalSetupContactConstraints(int iContactConstraint, @Const @ByRef btContactSolverInfo infoGlobal); + public native void internalConvertBodies(@Cast("btCollisionObject**") PointerPointer bodies, int iBegin, int iEnd, @Const @ByRef btContactSolverInfo infoGlobal); + public native void internalConvertBodies(@ByPtrPtr btCollisionObject bodies, int iBegin, int iEnd, @Const @ByRef btContactSolverInfo infoGlobal); + public native void internalWriteBackContacts(int iBegin, int iEnd, @Const @ByRef btContactSolverInfo infoGlobal); + public native void internalWriteBackJoints(int iBegin, int iEnd, @Const @ByRef btContactSolverInfo infoGlobal); + public native void internalWriteBackBodies(int iBegin, int iEnd, @Const @ByRef btContactSolverInfo infoGlobal); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java new file mode 100644 index 00000000000..f1d4343362b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java @@ -0,0 +1,105 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** + * SimulationIslandManagerMt -- Multithread capable version of SimulationIslandManager + * Splits the world up into islands which can be solved in parallel. + * In order to solve islands in parallel, an IslandDispatch function + * must be provided which will dispatch calls to multiple threads. + * The amount of parallelism that can be achieved depends on the number + * of islands. If only a single island exists, then no parallelism is + * possible. + * */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSimulationIslandManagerMt extends btSimulationIslandManager { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimulationIslandManagerMt(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSimulationIslandManagerMt(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSimulationIslandManagerMt position(long position) { + return (btSimulationIslandManagerMt)super.position(position); + } + @Override public btSimulationIslandManagerMt getPointer(long i) { + return new btSimulationIslandManagerMt((Pointer)this).offsetAddress(i); + } + + public static class Island extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public Island() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Island(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Island(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Island position(long position) { + return (Island)super.position(position); + } + @Override public Island getPointer(long i) { + return new Island((Pointer)this).offsetAddress(i); + } + + // a simulation island consisting of bodies, manifolds and constraints, + // to be passed into a constraint solver. + + + + public native int id(); public native Island id(int setter); // island id + public native @Cast("bool") boolean isSleeping(); public native Island isSleeping(boolean setter); + + public native void append(@Const @ByRef Island other); // add bodies, manifolds, constraints to my own + } + public static class SolverParams extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SolverParams() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SolverParams(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SolverParams(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SolverParams position(long position) { + return (SolverParams)super.position(position); + } + @Override public SolverParams getPointer(long i) { + return new SolverParams((Pointer)this).offsetAddress(i); + } + + public native btConstraintSolver m_solverPool(); public native SolverParams m_solverPool(btConstraintSolver setter); + public native btConstraintSolver m_solverMt(); public native SolverParams m_solverMt(btConstraintSolver setter); + public native btContactSolverInfo m_solverInfo(); public native SolverParams m_solverInfo(btContactSolverInfo setter); + public native btIDebugDraw m_debugDrawer(); public native SolverParams m_debugDrawer(btIDebugDraw setter); + public native btDispatcher m_dispatcher(); public native SolverParams m_dispatcher(btDispatcher setter); + } + public static native void solveIsland(btConstraintSolver solver, @ByRef Island island, @Const @ByRef SolverParams solverParams); + + + public btSimulationIslandManagerMt() { super((Pointer)null); allocate(); } + private native void allocate(); + + + + public native void buildIslands(btDispatcher dispatcher, btCollisionWorld colWorld); + + public native int getMinimumSolverBatchSize(); + public native void setMinimumSolverBatchSize(int sz); + // allow users to set their own dispatch function for multithreaded dispatch +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java new file mode 100644 index 00000000000..fd94f356878 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedObjectArray_char extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_char(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_char(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_char position(long position) { + return (btAlignedObjectArray_char)super.position(position); + } + @Override public btAlignedObjectArray_char getPointer(long i) { + return new btAlignedObjectArray_char((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_char put(@Const @ByRef btAlignedObjectArray_char other); + public btAlignedObjectArray_char() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_char(@Const @ByRef btAlignedObjectArray_char otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_char otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @Cast("char*") @ByRef BytePointer at(int n); + + public native @Cast("char*") @ByRef @Name("operator []") BytePointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Cast("const char") byte fillData/*=char()*/); + public native void resize(int newsize); + public native @Cast("char*") @ByRef BytePointer expandNonInitializing(); + + public native @Cast("char*") @ByRef BytePointer expand(@Cast("const char") byte fillValue/*=char()*/); + public native @Cast("char*") @ByRef BytePointer expand(); + + public native void push_back(@Cast("const char") byte _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Cast("const char") byte key); + + public native int findLinearSearch(@Cast("const char") byte key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Cast("const char") byte key); + + public native void removeAtIndex(int index); + public native void remove(@Cast("const char") byte key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_char otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index 1a68952c3c4..36911cab593 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -1448,6 +1448,35 @@ EPA Copyright (c) Ricardo Padrela 2006 // #endif //BT_UNION_FIND_H +// Parsed from BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_DISPATCHER_MT_H +// #define BT_COLLISION_DISPATCHER_MT_H + +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +// #include "LinearMath/btThreads.h" +// Targeting ../BulletCollision/btCollisionDispatcherMt.java + + + +// #endif //BT_COLLISION_DISPATCHER_MT_H + + // Parsed from BulletCollision/CollisionShapes/btCollisionShape.h /* diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index 109c2ac8528..5d9f7a66a28 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -309,6 +309,109 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #endif //BT_SIMPLE_DYNAMICS_WORLD_H +// Parsed from BulletDynamics/ConstraintSolver/btConstraintSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONSTRAINT_SOLVER_H +// #define BT_CONSTRAINT_SOLVER_H + +// #include "LinearMath/btScalar.h" +/** btConstraintSolver provides solver interface */ + +/** enum btConstraintSolverType */ +public static final int + BT_SEQUENTIAL_IMPULSE_SOLVER = 1, + BT_MLCP_SOLVER = 2, + BT_NNCG_SOLVER = 4, + BT_MULTIBODY_SOLVER = 8, + BT_BLOCK_SOLVER = 16; +// Targeting ../BulletDynamics/btConstraintSolver.java + + + +// #endif //BT_CONSTRAINT_SOLVER_H + + +// Parsed from BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DISCRETE_DYNAMICS_WORLD_MT_H +// #define BT_DISCRETE_DYNAMICS_WORLD_MT_H + +// #include "btDiscreteDynamicsWorld.h" +// #include "btSimulationIslandManagerMt.h" + + +/// +/// +/// +// #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" +// Targeting ../BulletDynamics/btConstraintSolverPoolMt.java + + +// Targeting ../BulletDynamics/btDiscreteDynamicsWorldMt.java + + + +// #endif //BT_DISCRETE_DYNAMICS_WORLD_H + + +// Parsed from BulletDynamics/Dynamics/btSimulationIslandManagerMt.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMULATION_ISLAND_MANAGER_MT_H +// #define BT_SIMULATION_ISLAND_MANAGER_MT_H + +// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" +// Targeting ../BulletDynamics/btSimulationIslandManagerMt.java + + + +// #endif //BT_SIMULATION_ISLAND_MANAGER_H + + // Parsed from BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h /* @@ -925,43 +1028,6 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_FIXED_CONSTRAINT_H -// Parsed from BulletDynamics/ConstraintSolver/btConstraintSolver.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CONSTRAINT_SOLVER_H -// #define BT_CONSTRAINT_SOLVER_H - -// #include "LinearMath/btScalar.h" -/** btConstraintSolver provides solver interface */ - -/** enum btConstraintSolverType */ -public static final int - BT_SEQUENTIAL_IMPULSE_SOLVER = 1, - BT_MLCP_SOLVER = 2, - BT_NNCG_SOLVER = 4, - BT_MULTIBODY_SOLVER = 8, - BT_BLOCK_SOLVER = 16; -// Targeting ../BulletDynamics/btConstraintSolver.java - - - -// #endif //BT_CONSTRAINT_SOLVER_H - - // Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h /* @@ -1162,6 +1228,76 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_TYPED_CONSTRAINT_H +// Parsed from BulletDynamics/ConstraintSolver/btBatchedConstraints.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BATCHED_CONSTRAINTS_H +// #define BT_BATCHED_CONSTRAINTS_H + +// #include "LinearMath/btThreads.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" +// #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" +// Targeting ../BulletDynamics/btBatchedConstraints.java + + + +// #endif // BT_BATCHED_CONSTRAINTS_H + + +// Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H +// #define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H + +// #include "btSequentialImpulseConstraintSolver.h" +// #include "btBatchedConstraints.h" + + +/// +/// +/// +/// +/// +/// +/// +// #include "LinearMath/btThreads.h" +// Targeting ../BulletDynamics/btSequentialImpulseConstraintSolverMt.java + + + +// #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H + + // Parsed from BulletDynamics/Vehicle/btVehicleRaycaster.h /* diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index 03dd7732703..7ea149d4141 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -711,6 +711,9 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // Targeting ../LinearMath/btAlignedObjectArray_bool.java +// Targeting ../LinearMath/btAlignedObjectArray_char.java + + // Targeting ../LinearMath/btAlignedObjectArray_int.java diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index c6c285cf339..0dd5aa6fd42 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -42,6 +42,7 @@ "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h", "BulletCollision/CollisionDispatch/btSimulationIslandManager.h", "BulletCollision/CollisionDispatch/btUnionFind.h", + "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h", "BulletCollision/CollisionShapes/btCollisionShape.h", "BulletCollision/CollisionShapes/btConvexShape.h", "BulletCollision/CollisionShapes/btConvexPolyhedron.h", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index f4c70369b07..d23729e4571 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -20,6 +20,9 @@ "BulletDynamics/ConstraintSolver/btContactSolverInfo.h", "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h", "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h", + "BulletDynamics/ConstraintSolver/btConstraintSolver.h", + "BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h", + "BulletDynamics/Dynamics/btSimulationIslandManagerMt.h", "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h", "BulletDynamics/ConstraintSolver/btHingeConstraint.h", "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h", @@ -31,11 +34,12 @@ "BulletDynamics/ConstraintSolver/btHinge2Constraint.h", "BulletDynamics/ConstraintSolver/btGearConstraint.h", "BulletDynamics/ConstraintSolver/btFixedConstraint.h", - "BulletDynamics/ConstraintSolver/btConstraintSolver.h", "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h", "BulletDynamics/ConstraintSolver/btSolverConstraint.h", "BulletDynamics/ConstraintSolver/btSolverBody.h", "BulletDynamics/ConstraintSolver/btTypedConstraint.h", + "BulletDynamics/ConstraintSolver/btBatchedConstraints.h", + "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h", "BulletDynamics/Vehicle/btVehicleRaycaster.h", "BulletDynamics/Vehicle/btWheelInfo.h", "BulletDynamics/Vehicle/btRaycastVehicle.h", @@ -127,6 +131,16 @@ public void map(InfoMap infoMap) { .put(new Info("btSimdScalar").cppText("#define btSimdScalar btScalar")) .put(new Info("btTypedConstraintData2").cppText("#define btTypedConstraintData2 btTypedConstraintFloatData")) .put(new Info("btConstraintArray").skip()) + .put(new Info("btSequentialImpulseConstraintSolverMt::internalConvertMultipleJoints").skip()) + .put(new Info("btBatchedConstraints::m_batches").skip()) + .put(new Info("btBatchedConstraints::m_phases").skip()) + .put(new Info("btSimulationIslandManagerMt::Island::bodyArray").skip()) + .put(new Info("btSimulationIslandManagerMt::Island::manifoldArray").skip()) + .put(new Info("btSimulationIslandManagerMt::Island::constraintArray").skip()) + .put(new Info("btSimulationIslandManagerMt::buildAndProcessIslands").skip()) + .put(new Info("btSimulationIslandManagerMt::serialIslandDispatch").skip()) + .put(new Info("btSimulationIslandManagerMt::parallelIslandDispatch").skip()) + .put(new Info("btSimulationIslandManagerMt::IslandDispatchFunc").skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index f1712dbb133..a9fb76b80a9 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -87,6 +87,7 @@ public void map(InfoMap infoMap) { // btAlignedObjectArray.h .put(new Info("btAlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_bool")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_char")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_int")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btScalar")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector3")) From b48ddebf06d5768a9b6acb8aa88dbe4feb419cfa Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 19 Feb 2022 22:36:13 +0800 Subject: [PATCH 14/81] Remove unnecessary btSoftBody bindings --- .../bullet/BulletSoftBody/btSoftBody.java | 112 +----------------- .../bullet/presets/BulletSoftBody.java | 6 + 2 files changed, 8 insertions(+), 110 deletions(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java index 42902a6275e..87ebffd62e2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java @@ -65,55 +65,8 @@ public static class eAeroModel extends Pointer { } /**eVSolver : velocities solvers */ - public static class eVSolver extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public eVSolver() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public eVSolver(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public eVSolver(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public eVSolver position(long position) { - return (eVSolver)super.position(position); - } - @Override public eVSolver getPointer(long i) { - return new eVSolver((Pointer)this).offsetAddress(i); - } - - /** enum btSoftBody::eVSolver::_ */ - public static final int - Linear = 0, /**Linear solver */ - END = 1; - } /**ePSolver : positions solvers */ - public static class ePSolver extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public ePSolver() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public ePSolver(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public ePSolver(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public ePSolver position(long position) { - return (ePSolver)super.position(position); - } - @Override public ePSolver getPointer(long i) { - return new ePSolver((Pointer)this).offsetAddress(i); - } - - /** enum btSoftBody::ePSolver::_ */ - public static final int - Linear = 0, /**Linear solver */ - Anchors = 1, /**Anchor solver */ - RContacts = 2, /**Rigid contacts solver */ - SContacts = 3, /**Soft contacts solver */ - END = 4; - } /**eSolverPresets */ public static class eSolverPresets extends Pointer { @@ -174,70 +127,8 @@ public static class eFeature extends Pointer { // /**fCollision */ - public static class fCollision extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public fCollision() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public fCollision(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public fCollision(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public fCollision position(long position) { - return (fCollision)super.position(position); - } - @Override public fCollision getPointer(long i) { - return new fCollision((Pointer)this).offsetAddress(i); - } - - /** enum btSoftBody::fCollision::_ */ - public static final int - RVSmask = 0x000f, /**Rigid versus soft mask */ - SDF_RS = 0x0001, /**SDF based rigid vs soft */ - CL_RS = 0x0002, /**Cluster vs convex rigid vs soft */ - SDF_RD = 0x0004, /**rigid vs deformable */ - - SVSmask = 0x00f0, /**Rigid versus soft mask */ - VF_SS = 0x0010, /**Vertex vs face soft vs soft handling */ - CL_SS = 0x0020, /**Cluster vs cluster soft vs soft handling */ - CL_SELF = 0x0040, /**Cluster soft body self collision */ - VF_DD = 0x0080, /**Vertex vs face soft vs soft handling */ - - RVDFmask = 0x0f00, /** Rigid versus deformable face mask */ - SDF_RDF = 0x0100, /** GJK based Rigid vs. deformable face */ - SDF_MDF = 0x0200, /** GJK based Multibody vs. deformable face */ - SDF_RDN = 0x0400, /** SDF based Rigid vs. deformable node */ - /* presets */ - Default = SDF_RS, - END = SDF_RS + 1; - } /**fMaterial */ - public static class fMaterial extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public fMaterial() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public fMaterial(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public fMaterial(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public fMaterial position(long position) { - return (fMaterial)super.position(position); - } - @Override public fMaterial getPointer(long i) { - return new fMaterial((Pointer)this).offsetAddress(i); - } - - /** enum btSoftBody::fMaterial::_ */ - public static final int - DebugDraw = 0x0001, /** Enable debug draw */ - /* presets */ - Default = DebugDraw, - END = DebugDraw + 1; - } // // API Types @@ -1657,7 +1548,8 @@ public native int rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVecto public static native void PSolve_SContacts(btSoftBody psb, @Cast("btScalar") float arg1, @Cast("btScalar") float ti); public static native void PSolve_Links(btSoftBody psb, @Cast("btScalar") float kst, @Cast("btScalar") float ti); public static native void VSolve_Links(btSoftBody psb, @Cast("btScalar") float kst); - public static native psolver_t getSolver(@Cast("btSoftBody::ePSolver::_") int solver); + + public native void geometricCollisionHandler(btSoftBody psb); // #define SAFE_EPSILON SIMD_EPSILON * 100.0 diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 87e66f4421f..2aa072478f7 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -91,6 +91,12 @@ public void map(InfoMap infoMap) { .put(new Info("btDeformableBackwardEulerObjective::m_projection").skip()) .put(new Info("btDeformableLagrangianForce::m_nodes").skip()) .put(new Info("btDeformableLagrangianForce::setIndices").skip()) + + .put(new Info("btSoftBody::eVSolver").skip()) + .put(new Info("btSoftBody::ePSolver").skip()) + .put(new Info("btSoftBody::getSolver").skip()) + .put(new Info("btSoftBody::fMaterial").skip()) + .put(new Info("btSoftBody::fCollision").skip()) ; } } From 894cd8d75ba08cb8d156fb7b8d18e0c06235aa9f Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 19 Feb 2022 22:36:50 +0800 Subject: [PATCH 15/81] Generate btAlignedObjectArray instances for btSoftBody sub-classes Fix generated types of btSoftBody array-based members. --- ...tAlignedObjectArray_btSoftBody_Anchor.java | 92 +++++++++++++++++++ ...ObjectArray_btSoftBody_ClusterPointer.java | 92 +++++++++++++++++++ .../btAlignedObjectArray_btSoftBody_Face.java | 92 +++++++++++++++++++ ...edObjectArray_btSoftBody_JointPointer.java | 92 +++++++++++++++++++ .../btAlignedObjectArray_btSoftBody_Link.java | 92 +++++++++++++++++++ ...bjectArray_btSoftBody_MaterialPointer.java | 92 +++++++++++++++++++ .../btAlignedObjectArray_btSoftBody_Node.java | 92 +++++++++++++++++++ .../btAlignedObjectArray_btSoftBody_Note.java | 92 +++++++++++++++++++ ...lignedObjectArray_btSoftBody_RContact.java | 92 +++++++++++++++++++ ...gnedObjectArray_btSoftBody_RenderFace.java | 92 +++++++++++++++++++ ...gnedObjectArray_btSoftBody_RenderNode.java | 92 +++++++++++++++++++ ...lignedObjectArray_btSoftBody_SContact.java | 92 +++++++++++++++++++ ...btAlignedObjectArray_btSoftBody_Tetra.java | 92 +++++++++++++++++++ .../bullet/BulletSoftBody/btSoftBody.java | 26 +++--- .../bullet/global/BulletSoftBody.java | 39 ++++++++ .../bullet/presets/BulletSoftBody.java | 92 +++++++++++++++++++ 16 files changed, 1340 insertions(+), 13 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java new file mode 100644 index 00000000000..9ebbddb235b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_Anchor extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_Anchor(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_Anchor(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_Anchor position(long position) { + return (btAlignedObjectArray_btSoftBody_Anchor)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_Anchor getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_Anchor((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Anchor put(@Const @ByRef btAlignedObjectArray_btSoftBody_Anchor other); + public btAlignedObjectArray_btSoftBody_Anchor() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_Anchor(@Const @ByRef btAlignedObjectArray_btSoftBody_Anchor otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Anchor otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.Anchor at(int n); + + public native @ByRef @Name("operator []") btSoftBody.Anchor get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::Anchor()") btSoftBody.Anchor fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.Anchor expandNonInitializing(); + + public native @ByRef btSoftBody.Anchor expand(@Const @ByRef(nullValue = "btSoftBody::Anchor()") btSoftBody.Anchor fillValue); + public native @ByRef btSoftBody.Anchor expand(); + + public native void push_back(@Const @ByRef btSoftBody.Anchor _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Anchor otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java new file mode 100644 index 00000000000..da390c271ec --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_ClusterPointer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_ClusterPointer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_ClusterPointer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_ClusterPointer position(long position) { + return (btAlignedObjectArray_btSoftBody_ClusterPointer)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_ClusterPointer getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_ClusterPointer((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_ClusterPointer put(@Const @ByRef btAlignedObjectArray_btSoftBody_ClusterPointer other); + public btAlignedObjectArray_btSoftBody_ClusterPointer() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_ClusterPointer(@Const @ByRef btAlignedObjectArray_btSoftBody_ClusterPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_ClusterPointer otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btSoftBody.Cluster at(int n); + + public native @ByPtrRef @Name("operator []") btSoftBody.Cluster get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btSoftBody.Cluster fillData/*=btSoftBody::Cluster*()*/); + public native void resize(int newsize); + public native @ByPtrRef btSoftBody.Cluster expandNonInitializing(); + + public native @ByPtrRef btSoftBody.Cluster expand(@ByPtrRef btSoftBody.Cluster fillValue/*=btSoftBody::Cluster*()*/); + public native @ByPtrRef btSoftBody.Cluster expand(); + + public native void push_back(@ByPtrRef btSoftBody.Cluster _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btSoftBody.Cluster key); + + public native int findLinearSearch(@ByPtrRef btSoftBody.Cluster key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btSoftBody.Cluster key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btSoftBody.Cluster key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_ClusterPointer otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java new file mode 100644 index 00000000000..ebd7166a960 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_Face extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_Face(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_Face(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_Face position(long position) { + return (btAlignedObjectArray_btSoftBody_Face)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_Face getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_Face((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Face put(@Const @ByRef btAlignedObjectArray_btSoftBody_Face other); + public btAlignedObjectArray_btSoftBody_Face() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_Face(@Const @ByRef btAlignedObjectArray_btSoftBody_Face otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Face otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.Face at(int n); + + public native @ByRef @Name("operator []") btSoftBody.Face get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::Face()") btSoftBody.Face fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.Face expandNonInitializing(); + + public native @ByRef btSoftBody.Face expand(@Const @ByRef(nullValue = "btSoftBody::Face()") btSoftBody.Face fillValue); + public native @ByRef btSoftBody.Face expand(); + + public native void push_back(@Const @ByRef btSoftBody.Face _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Face otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java new file mode 100644 index 00000000000..e8071a1415e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_JointPointer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_JointPointer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_JointPointer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_JointPointer position(long position) { + return (btAlignedObjectArray_btSoftBody_JointPointer)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_JointPointer getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_JointPointer((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_JointPointer put(@Const @ByRef btAlignedObjectArray_btSoftBody_JointPointer other); + public btAlignedObjectArray_btSoftBody_JointPointer() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_JointPointer(@Const @ByRef btAlignedObjectArray_btSoftBody_JointPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_JointPointer otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btSoftBody.Joint at(int n); + + public native @ByPtrRef @Name("operator []") btSoftBody.Joint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btSoftBody.Joint fillData/*=btSoftBody::Joint*()*/); + public native void resize(int newsize); + public native @ByPtrRef btSoftBody.Joint expandNonInitializing(); + + public native @ByPtrRef btSoftBody.Joint expand(@ByPtrRef btSoftBody.Joint fillValue/*=btSoftBody::Joint*()*/); + public native @ByPtrRef btSoftBody.Joint expand(); + + public native void push_back(@ByPtrRef btSoftBody.Joint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btSoftBody.Joint key); + + public native int findLinearSearch(@ByPtrRef btSoftBody.Joint key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btSoftBody.Joint key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btSoftBody.Joint key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_JointPointer otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java new file mode 100644 index 00000000000..b49ec8aeb1f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_Link extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_Link(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_Link(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_Link position(long position) { + return (btAlignedObjectArray_btSoftBody_Link)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_Link getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_Link((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Link put(@Const @ByRef btAlignedObjectArray_btSoftBody_Link other); + public btAlignedObjectArray_btSoftBody_Link() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_Link(@Const @ByRef btAlignedObjectArray_btSoftBody_Link otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Link otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.Link at(int n); + + public native @ByRef @Name("operator []") btSoftBody.Link get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::Link()") btSoftBody.Link fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.Link expandNonInitializing(); + + public native @ByRef btSoftBody.Link expand(@Const @ByRef(nullValue = "btSoftBody::Link()") btSoftBody.Link fillValue); + public native @ByRef btSoftBody.Link expand(); + + public native void push_back(@Const @ByRef btSoftBody.Link _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Link otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java new file mode 100644 index 00000000000..e0609d4f749 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_MaterialPointer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_MaterialPointer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_MaterialPointer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_MaterialPointer position(long position) { + return (btAlignedObjectArray_btSoftBody_MaterialPointer)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_MaterialPointer getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_MaterialPointer((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_MaterialPointer put(@Const @ByRef btAlignedObjectArray_btSoftBody_MaterialPointer other); + public btAlignedObjectArray_btSoftBody_MaterialPointer() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_MaterialPointer(@Const @ByRef btAlignedObjectArray_btSoftBody_MaterialPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_MaterialPointer otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btSoftBody.Material at(int n); + + public native @ByPtrRef @Name("operator []") btSoftBody.Material get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btSoftBody.Material fillData/*=btSoftBody::Material*()*/); + public native void resize(int newsize); + public native @ByPtrRef btSoftBody.Material expandNonInitializing(); + + public native @ByPtrRef btSoftBody.Material expand(@ByPtrRef btSoftBody.Material fillValue/*=btSoftBody::Material*()*/); + public native @ByPtrRef btSoftBody.Material expand(); + + public native void push_back(@ByPtrRef btSoftBody.Material _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btSoftBody.Material key); + + public native int findLinearSearch(@ByPtrRef btSoftBody.Material key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btSoftBody.Material key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btSoftBody.Material key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_MaterialPointer otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java new file mode 100644 index 00000000000..832f2b6610a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_Node extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_Node(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_Node(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_Node position(long position) { + return (btAlignedObjectArray_btSoftBody_Node)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_Node getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_Node((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Node put(@Const @ByRef btAlignedObjectArray_btSoftBody_Node other); + public btAlignedObjectArray_btSoftBody_Node() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_Node(@Const @ByRef btAlignedObjectArray_btSoftBody_Node otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Node otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.Node at(int n); + + public native @ByRef @Name("operator []") btSoftBody.Node get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::Node()") btSoftBody.Node fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.Node expandNonInitializing(); + + public native @ByRef btSoftBody.Node expand(@Const @ByRef(nullValue = "btSoftBody::Node()") btSoftBody.Node fillValue); + public native @ByRef btSoftBody.Node expand(); + + public native void push_back(@Const @ByRef btSoftBody.Node _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Node otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java new file mode 100644 index 00000000000..8e31bc256bd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_Note extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_Note(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_Note(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_Note position(long position) { + return (btAlignedObjectArray_btSoftBody_Note)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_Note getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_Note((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Note put(@Const @ByRef btAlignedObjectArray_btSoftBody_Note other); + public btAlignedObjectArray_btSoftBody_Note() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_Note(@Const @ByRef btAlignedObjectArray_btSoftBody_Note otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Note otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.Note at(int n); + + public native @ByRef @Name("operator []") btSoftBody.Note get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::Note()") btSoftBody.Note fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.Note expandNonInitializing(); + + public native @ByRef btSoftBody.Note expand(@Const @ByRef(nullValue = "btSoftBody::Note()") btSoftBody.Note fillValue); + public native @ByRef btSoftBody.Note expand(); + + public native void push_back(@Const @ByRef btSoftBody.Note _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Note otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java new file mode 100644 index 00000000000..4313aee8a01 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_RContact extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_RContact(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_RContact(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_RContact position(long position) { + return (btAlignedObjectArray_btSoftBody_RContact)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_RContact getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_RContact((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_RContact put(@Const @ByRef btAlignedObjectArray_btSoftBody_RContact other); + public btAlignedObjectArray_btSoftBody_RContact() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_RContact(@Const @ByRef btAlignedObjectArray_btSoftBody_RContact otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_RContact otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.RContact at(int n); + + public native @ByRef @Name("operator []") btSoftBody.RContact get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::RContact()") btSoftBody.RContact fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.RContact expandNonInitializing(); + + public native @ByRef btSoftBody.RContact expand(@Const @ByRef(nullValue = "btSoftBody::RContact()") btSoftBody.RContact fillValue); + public native @ByRef btSoftBody.RContact expand(); + + public native void push_back(@Const @ByRef btSoftBody.RContact _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_RContact otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java new file mode 100644 index 00000000000..4f4199e9dd9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_RenderFace extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_RenderFace(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_RenderFace(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_RenderFace position(long position) { + return (btAlignedObjectArray_btSoftBody_RenderFace)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_RenderFace getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_RenderFace((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_RenderFace put(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderFace other); + public btAlignedObjectArray_btSoftBody_RenderFace() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_RenderFace(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderFace otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderFace otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.RenderFace at(int n); + + public native @ByRef @Name("operator []") btSoftBody.RenderFace get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::RenderFace()") btSoftBody.RenderFace fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.RenderFace expandNonInitializing(); + + public native @ByRef btSoftBody.RenderFace expand(@Const @ByRef(nullValue = "btSoftBody::RenderFace()") btSoftBody.RenderFace fillValue); + public native @ByRef btSoftBody.RenderFace expand(); + + public native void push_back(@Const @ByRef btSoftBody.RenderFace _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderFace otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java new file mode 100644 index 00000000000..9bdc4cbc2d3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_RenderNode extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_RenderNode(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_RenderNode(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_RenderNode position(long position) { + return (btAlignedObjectArray_btSoftBody_RenderNode)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_RenderNode getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_RenderNode((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_RenderNode put(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderNode other); + public btAlignedObjectArray_btSoftBody_RenderNode() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_RenderNode(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderNode otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderNode otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.RenderNode at(int n); + + public native @ByRef @Name("operator []") btSoftBody.RenderNode get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::RenderNode()") btSoftBody.RenderNode fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.RenderNode expandNonInitializing(); + + public native @ByRef btSoftBody.RenderNode expand(@Const @ByRef(nullValue = "btSoftBody::RenderNode()") btSoftBody.RenderNode fillValue); + public native @ByRef btSoftBody.RenderNode expand(); + + public native void push_back(@Const @ByRef btSoftBody.RenderNode _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderNode otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java new file mode 100644 index 00000000000..1f4415f7f44 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_SContact extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_SContact(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_SContact(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_SContact position(long position) { + return (btAlignedObjectArray_btSoftBody_SContact)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_SContact getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_SContact((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_SContact put(@Const @ByRef btAlignedObjectArray_btSoftBody_SContact other); + public btAlignedObjectArray_btSoftBody_SContact() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_SContact(@Const @ByRef btAlignedObjectArray_btSoftBody_SContact otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_SContact otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.SContact at(int n); + + public native @ByRef @Name("operator []") btSoftBody.SContact get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::SContact()") btSoftBody.SContact fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.SContact expandNonInitializing(); + + public native @ByRef btSoftBody.SContact expand(@Const @ByRef(nullValue = "btSoftBody::SContact()") btSoftBody.SContact fillValue); + public native @ByRef btSoftBody.SContact expand(); + + public native void push_back(@Const @ByRef btSoftBody.SContact _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_SContact otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java new file mode 100644 index 00000000000..ea931c39caf --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btAlignedObjectArray_btSoftBody_Tetra extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btSoftBody_Tetra(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btSoftBody_Tetra(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btSoftBody_Tetra position(long position) { + return (btAlignedObjectArray_btSoftBody_Tetra)super.position(position); + } + @Override public btAlignedObjectArray_btSoftBody_Tetra getPointer(long i) { + return new btAlignedObjectArray_btSoftBody_Tetra((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Tetra put(@Const @ByRef btAlignedObjectArray_btSoftBody_Tetra other); + public btAlignedObjectArray_btSoftBody_Tetra() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btSoftBody_Tetra(@Const @ByRef btAlignedObjectArray_btSoftBody_Tetra otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Tetra otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.Tetra at(int n); + + public native @ByRef @Name("operator []") btSoftBody.Tetra get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::Tetra()") btSoftBody.Tetra fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.Tetra expandNonInitializing(); + + public native @ByRef btSoftBody.Tetra expand(@Const @ByRef(nullValue = "btSoftBody::Tetra()") btSoftBody.Tetra fillValue); + public native @ByRef btSoftBody.Tetra expand(); + + public native void push_back(@Const @ByRef btSoftBody.Tetra _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Tetra otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java index 87ebffd62e2..6d378b2679b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java @@ -1133,24 +1133,24 @@ public static class vsolver_t extends FunctionPointer { public native @ByRef Pose m_pose(); public native btSoftBody m_pose(Pose setter); // Pose public native Pointer m_tag(); public native btSoftBody m_tag(Pointer setter); // User data public native btSoftBodyWorldInfo m_worldInfo(); public native btSoftBody m_worldInfo(btSoftBodyWorldInfo setter); // World info - public native @ByRef @Cast("btSoftBody::tNoteArray*") btAlignedObjectArray_btSoftBody m_notes(); public native btSoftBody m_notes(btAlignedObjectArray_btSoftBody setter); // Notes - public native @ByRef @Cast("btSoftBody::tNodeArray*") btAlignedObjectArray_btSoftBody m_nodes(); public native btSoftBody m_nodes(btAlignedObjectArray_btSoftBody setter); // Nodes - public native @ByRef @Cast("btSoftBody::tRenderNodeArray*") btAlignedObjectArray_btSoftBody m_renderNodes(); public native btSoftBody m_renderNodes(btAlignedObjectArray_btSoftBody setter); // Render Nodes - public native @ByRef @Cast("btSoftBody::tLinkArray*") btAlignedObjectArray_btSoftBody m_links(); public native btSoftBody m_links(btAlignedObjectArray_btSoftBody setter); // Links - public native @ByRef @Cast("btSoftBody::tFaceArray*") btAlignedObjectArray_btSoftBody m_faces(); public native btSoftBody m_faces(btAlignedObjectArray_btSoftBody setter); // Faces - public native @ByRef @Cast("btSoftBody::tRenderFaceArray*") btAlignedObjectArray_btSoftBody m_renderFaces(); public native btSoftBody m_renderFaces(btAlignedObjectArray_btSoftBody setter); // Faces - public native @ByRef @Cast("btSoftBody::tTetraArray*") btAlignedObjectArray_btSoftBody m_tetras(); public native btSoftBody m_tetras(btAlignedObjectArray_btSoftBody setter); // Tetras + public native @ByRef @Cast("btSoftBody::tNoteArray*") btAlignedObjectArray_btSoftBody_Note m_notes(); public native btSoftBody m_notes(btAlignedObjectArray_btSoftBody_Note setter); // Notes + public native @ByRef @Cast("btSoftBody::tNodeArray*") btAlignedObjectArray_btSoftBody_Node m_nodes(); public native btSoftBody m_nodes(btAlignedObjectArray_btSoftBody_Node setter); // Nodes + public native @ByRef @Cast("btSoftBody::tRenderNodeArray*") btAlignedObjectArray_btSoftBody_RenderNode m_renderNodes(); public native btSoftBody m_renderNodes(btAlignedObjectArray_btSoftBody_RenderNode setter); // Render Nodes + public native @ByRef @Cast("btSoftBody::tLinkArray*") btAlignedObjectArray_btSoftBody_Link m_links(); public native btSoftBody m_links(btAlignedObjectArray_btSoftBody_Link setter); // Links + public native @ByRef @Cast("btSoftBody::tFaceArray*") btAlignedObjectArray_btSoftBody_Face m_faces(); public native btSoftBody m_faces(btAlignedObjectArray_btSoftBody_Face setter); // Faces + public native @ByRef @Cast("btSoftBody::tRenderFaceArray*") btAlignedObjectArray_btSoftBody_RenderFace m_renderFaces(); public native btSoftBody m_renderFaces(btAlignedObjectArray_btSoftBody_RenderFace setter); // Faces + public native @ByRef @Cast("btSoftBody::tTetraArray*") btAlignedObjectArray_btSoftBody_Tetra m_tetras(); public native btSoftBody m_tetras(btAlignedObjectArray_btSoftBody_Tetra setter); // Tetras - public native @ByRef @Cast("btSoftBody::tAnchorArray*") btAlignedObjectArray_btSoftBody m_anchors(); public native btSoftBody m_anchors(btAlignedObjectArray_btSoftBody setter); // Anchors + public native @ByRef @Cast("btSoftBody::tAnchorArray*") btAlignedObjectArray_btSoftBody_Anchor m_anchors(); public native btSoftBody m_anchors(btAlignedObjectArray_btSoftBody_Anchor setter); // Anchors - public native @ByRef @Cast("btSoftBody::tRContactArray*") btAlignedObjectArray_btSoftBody m_rcontacts(); public native btSoftBody m_rcontacts(btAlignedObjectArray_btSoftBody setter); // Rigid contacts + public native @ByRef @Cast("btSoftBody::tRContactArray*") btAlignedObjectArray_btSoftBody_RContact m_rcontacts(); public native btSoftBody m_rcontacts(btAlignedObjectArray_btSoftBody_RContact setter); // Rigid contacts - public native @ByRef @Cast("btSoftBody::tSContactArray*") btAlignedObjectArray_btSoftBody m_scontacts(); public native btSoftBody m_scontacts(btAlignedObjectArray_btSoftBody setter); // Soft contacts - public native @ByRef @Cast("btSoftBody::tJointArray*") btAlignedObjectArray_btSoftBody m_joints(); public native btSoftBody m_joints(btAlignedObjectArray_btSoftBody setter); // Joints - public native @ByRef @Cast("btSoftBody::tMaterialArray*") btAlignedObjectArray_btSoftBody m_materials(); public native btSoftBody m_materials(btAlignedObjectArray_btSoftBody setter); // Materials + public native @ByRef @Cast("btSoftBody::tSContactArray*") btAlignedObjectArray_btSoftBody_SContact m_scontacts(); public native btSoftBody m_scontacts(btAlignedObjectArray_btSoftBody_SContact setter); // Soft contacts + public native @ByRef @Cast("btSoftBody::tJointArray*") btAlignedObjectArray_btSoftBody_JointPointer m_joints(); public native btSoftBody m_joints(btAlignedObjectArray_btSoftBody_JointPointer setter); // Joints + public native @ByRef @Cast("btSoftBody::tMaterialArray*") btAlignedObjectArray_btSoftBody_MaterialPointer m_materials(); public native btSoftBody m_materials(btAlignedObjectArray_btSoftBody_MaterialPointer setter); // Materials public native @Cast("btScalar") float m_timeacc(); public native btSoftBody m_timeacc(float setter); // Time accumulator public native @ByRef btVector3 m_bounds(int i); public native btSoftBody m_bounds(int i, btVector3 setter); @MemberGetter public native btVector3 m_bounds(); // Spatial bounds @@ -1159,7 +1159,7 @@ public static class vsolver_t extends FunctionPointer { public native @ByRef btDbvt m_fdbvt(); public native btSoftBody m_fdbvt(btDbvt setter); // Faces tree // Faces tree with normals public native @ByRef btDbvt m_cdbvt(); public native btSoftBody m_cdbvt(btDbvt setter); // Clusters tree - public native @ByRef @Cast("btSoftBody::tClusterArray*") btAlignedObjectArray_btSoftBody m_clusters(); public native btSoftBody m_clusters(btAlignedObjectArray_btSoftBody setter); // Clusters + public native @ByRef @Cast("btSoftBody::tClusterArray*") btAlignedObjectArray_btSoftBody_ClusterPointer m_clusters(); public native btSoftBody m_clusters(btAlignedObjectArray_btSoftBody_ClusterPointer setter); // Clusters public native @Cast("btScalar") float m_dampingCoefficient(); public native btSoftBody m_dampingCoefficient(float setter); // Damping Coefficient public native @Cast("btScalar") float m_sleepingThreshold(); public native btSoftBody m_sleepingThreshold(float setter); public native @Cast("btScalar") float m_maxSpeedSquared(); public native btSoftBody m_maxSpeedSquared(float setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index 40d1d7a5bd8..c2e44139e5b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -62,6 +62,45 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java + + // #endif //BT_OBJECT_ARRAY__ diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 2aa072478f7..47bccb5a613 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -92,6 +92,98 @@ public void map(InfoMap infoMap) { .put(new Info("btDeformableLagrangianForce::m_nodes").skip()) .put(new Info("btDeformableLagrangianForce::setIndices").skip()) + // typedef btAlignedObjectArray tFaceArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Face")) + .put(new Info("btSoftBody::Face").pointerTypes("btSoftBody.Face")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tNoteArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Note")) + .put(new Info("btSoftBody::Note").pointerTypes("btSoftBody.Note")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tNodeArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Node")) + .put(new Info("btSoftBody::Node").pointerTypes("btSoftBody.Node")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tRenderNodeArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RenderNode")) + .put(new Info("btSoftBody::RenderNode").pointerTypes("btSoftBody.RenderNode")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tClusterArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_ClusterPointer")) + .put(new Info("btSoftBody::Cluster").pointerTypes("btSoftBody.Cluster")) + + // typedef btAlignedObjectArray tLinkArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Link")) + .put(new Info("btSoftBody::Link").pointerTypes("btSoftBody.Link")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tRenderFaceArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RenderFace")) + .put(new Info("btSoftBody::RenderFace").pointerTypes("btSoftBody.RenderFace")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tTetraArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Tetra")) + .put(new Info("btSoftBody::Tetra").pointerTypes("btSoftBody.Tetra")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tAnchorArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Anchor")) + .put(new Info("btSoftBody::Anchor").pointerTypes("btSoftBody.Anchor")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tRContactArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RContact")) + .put(new Info("btSoftBody::RContact").pointerTypes("btSoftBody.RContact")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tSContactArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_SContact")) + .put(new Info("btSoftBody::SContact").pointerTypes("btSoftBody.SContact")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + // typedef btAlignedObjectArray tMaterialArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_MaterialPointer")) + .put(new Info("btSoftBody::Material").pointerTypes("btSoftBody.Material")) + + // typedef btAlignedObjectArray tJointArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_JointPointer")) + .put(new Info("btSoftBody::Joint").pointerTypes("btSoftBody.Joint")) + .put(new Info("btSoftBody::eVSolver").skip()) .put(new Info("btSoftBody::ePSolver").skip()) .put(new Info("btSoftBody::getSolver").skip()) From 4ddbb320778a79f02d21de51060ff3dbc29181d9 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 19 Feb 2022 23:00:10 +0800 Subject: [PATCH 16/81] Fix generated types for some btAlignedObjectArray instances --- ...btAlignedObjectArray_btBvhSubtreeInfo.java | 88 ++++++++++++++++++ ...dObjectArray_btCollisionObjectPointer.java | 92 +++++++++++++++++++ ...jectArray_btPersistentManifoldPointer.java | 88 ++++++++++++++++++ ...AlignedObjectArray_btQuantizedBvhNode.java | 88 ++++++++++++++++++ .../BulletCollision/btCollisionAlgorithm.java | 2 +- .../BulletCollision/btCollisionWorld.java | 2 +- .../BulletCollision/btQuantizedBvh.java | 6 +- .../btTriangleIndexVertexArray.java | 2 +- .../bullet/global/BulletCollision.java | 56 +++++++++++ .../bullet/presets/BulletCollision.java | 15 +++ 10 files changed, 433 insertions(+), 6 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java new file mode 100644 index 00000000000..fb233600d55 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btAlignedObjectArray_btBvhSubtreeInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btBvhSubtreeInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btBvhSubtreeInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btBvhSubtreeInfo position(long position) { + return (btAlignedObjectArray_btBvhSubtreeInfo)super.position(position); + } + @Override public btAlignedObjectArray_btBvhSubtreeInfo getPointer(long i) { + return new btAlignedObjectArray_btBvhSubtreeInfo((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btBvhSubtreeInfo put(@Const @ByRef btAlignedObjectArray_btBvhSubtreeInfo other); + public btAlignedObjectArray_btBvhSubtreeInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btBvhSubtreeInfo(@Const @ByRef btAlignedObjectArray_btBvhSubtreeInfo otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btBvhSubtreeInfo otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btBvhSubtreeInfo at(int n); + + public native @ByRef @Name("operator []") btBvhSubtreeInfo get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btBvhSubtreeInfo()") btBvhSubtreeInfo fillData); + public native void resize(int newsize); + public native @ByRef btBvhSubtreeInfo expandNonInitializing(); + + public native @ByRef btBvhSubtreeInfo expand(@Const @ByRef(nullValue = "btBvhSubtreeInfo()") btBvhSubtreeInfo fillValue); + public native @ByRef btBvhSubtreeInfo expand(); + + public native void push_back(@Const @ByRef btBvhSubtreeInfo _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btBvhSubtreeInfo otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java new file mode 100644 index 00000000000..cee54898d6c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btAlignedObjectArray_btCollisionObjectPointer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btCollisionObjectPointer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btCollisionObjectPointer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btCollisionObjectPointer position(long position) { + return (btAlignedObjectArray_btCollisionObjectPointer)super.position(position); + } + @Override public btAlignedObjectArray_btCollisionObjectPointer getPointer(long i) { + return new btAlignedObjectArray_btCollisionObjectPointer((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btCollisionObjectPointer put(@Const @ByRef btAlignedObjectArray_btCollisionObjectPointer other); + public btAlignedObjectArray_btCollisionObjectPointer() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btCollisionObjectPointer(@Const @ByRef btAlignedObjectArray_btCollisionObjectPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btCollisionObjectPointer otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btCollisionObject at(int n); + + public native @ByPtrRef @Name("operator []") btCollisionObject get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btCollisionObject fillData/*=btCollisionObject*()*/); + public native void resize(int newsize); + public native @ByPtrRef btCollisionObject expandNonInitializing(); + + public native @ByPtrRef btCollisionObject expand(@ByPtrRef btCollisionObject fillValue/*=btCollisionObject*()*/); + public native @ByPtrRef btCollisionObject expand(); + + public native void push_back(@ByPtrRef btCollisionObject _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btCollisionObject key); + + public native int findLinearSearch(@ByPtrRef btCollisionObject key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btCollisionObject key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btCollisionObject key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btCollisionObjectPointer otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java new file mode 100644 index 00000000000..0f13952aeaa --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btAlignedObjectArray_btPersistentManifoldPointer extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btPersistentManifoldPointer(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btPersistentManifoldPointer(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btPersistentManifoldPointer position(long position) { + return (btAlignedObjectArray_btPersistentManifoldPointer)super.position(position); + } + @Override public btAlignedObjectArray_btPersistentManifoldPointer getPointer(long i) { + return new btAlignedObjectArray_btPersistentManifoldPointer((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btPersistentManifoldPointer put(@Const @ByRef btAlignedObjectArray_btPersistentManifoldPointer other); + public btAlignedObjectArray_btPersistentManifoldPointer() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btPersistentManifoldPointer(@Const @ByRef btAlignedObjectArray_btPersistentManifoldPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btPersistentManifoldPointer otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btPersistentManifold at(int n); + + public native @ByPtrRef @Name("operator []") btPersistentManifold get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btPersistentManifold fillData/*=btPersistentManifold*()*/); + public native void resize(int newsize); + public native @ByPtrRef btPersistentManifold expandNonInitializing(); + + public native @ByPtrRef btPersistentManifold expand(@ByPtrRef btPersistentManifold fillValue/*=btPersistentManifold*()*/); + public native @ByPtrRef btPersistentManifold expand(); + + public native void push_back(@ByPtrRef btPersistentManifold _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btPersistentManifold key); + + public native int findLinearSearch(@ByPtrRef btPersistentManifold key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btPersistentManifold key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btPersistentManifold key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btPersistentManifoldPointer otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java new file mode 100644 index 00000000000..8a41d401c3c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btAlignedObjectArray_btQuantizedBvhNode extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btQuantizedBvhNode(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btQuantizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btQuantizedBvhNode position(long position) { + return (btAlignedObjectArray_btQuantizedBvhNode)super.position(position); + } + @Override public btAlignedObjectArray_btQuantizedBvhNode getPointer(long i) { + return new btAlignedObjectArray_btQuantizedBvhNode((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btQuantizedBvhNode put(@Const @ByRef btAlignedObjectArray_btQuantizedBvhNode other); + public btAlignedObjectArray_btQuantizedBvhNode() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btQuantizedBvhNode(@Const @ByRef btAlignedObjectArray_btQuantizedBvhNode otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btQuantizedBvhNode otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btQuantizedBvhNode at(int n); + + public native @ByRef @Name("operator []") btQuantizedBvhNode get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btQuantizedBvhNode()") btQuantizedBvhNode fillData); + public native void resize(int newsize); + public native @ByRef btQuantizedBvhNode expandNonInitializing(); + + public native @ByRef btQuantizedBvhNode expand(@Const @ByRef(nullValue = "btQuantizedBvhNode()") btQuantizedBvhNode fillValue); + public native @ByRef btQuantizedBvhNode expand(); + + public native void push_back(@Const @ByRef btQuantizedBvhNode _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btQuantizedBvhNode otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java index 34640a27b01..a35d84e6ad3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java @@ -26,5 +26,5 @@ public class btCollisionAlgorithm extends Pointer { public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); - public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btAlignedObjectArray_bool manifoldArray); + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btAlignedObjectArray_btPersistentManifoldPointer manifoldArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java index 3b88736f9c0..8a5b866617f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java @@ -271,7 +271,7 @@ public static native void objectQuerySingleInternal(@Const btConvexShape castSha public native void refreshBroadphaseProxy(btCollisionObject collisionObject); - public native @Cast("btCollisionObjectArray*") @ByRef btAlignedObjectArray_bool getCollisionObjectArray(); + public native @Cast("btCollisionObjectArray*") @ByRef btAlignedObjectArray_btCollisionObjectPointer getCollisionObjectArray(); public native void removeCollisionObject(btCollisionObject collisionObject); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java index 9436000bf80..c79eeab1d76 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java @@ -43,7 +43,7 @@ public class btQuantizedBvh extends Pointer { ///***************************************** expert/internal use only ************************* public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("btScalar") float quantizationMargin/*=btScalar(1.0)*/); public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); - public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_bool getLeafNodeArray(); + public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btQuantizedBvhNode getLeafNodeArray(); /**buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized */ public native void buildInternal(); ///***************************************** expert/internal use only ************************* @@ -67,9 +67,9 @@ public class btQuantizedBvh extends Pointer { /**setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees. */ public native void setTraversalMode(@Cast("btQuantizedBvh::btTraversalMode") int traversalMode); - public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_bool getQuantizedNodeArray(); + public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btQuantizedBvhNode getQuantizedNodeArray(); - public native @Cast("BvhSubtreeInfoArray*") @ByRef btAlignedObjectArray_bool getSubtreeInfoArray(); + public native @Cast("BvhSubtreeInfoArray*") @ByRef btAlignedObjectArray_btBvhSubtreeInfo getSubtreeInfoArray(); //////////////////////////////////////////////////////////////////// diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java index bcb403b31aa..50aaf969d4b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java @@ -73,7 +73,7 @@ public class btTriangleIndexVertexArray extends btStridingMeshInterface { * each subpart has a continuous array of vertices and indices */ public native int getNumSubParts(); - public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_bool getIndexedMeshArray(); + public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btCollisionObjectPointer getIndexedMeshArray(); public native void preallocateVertices(int numverts); public native void preallocateIndices(int numindices); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index 36911cab593..b7726023c31 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -15,6 +15,62 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision { static { Loader.load(); } +// Parsed from LinearMath/btAlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBJECT_ARRAY__ +// #define BT_OBJECT_ARRAY__ + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE +// #include "btAlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable BT_USE_PLACEMENT_NEW + * then the btAlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable BT_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int BT_USE_PLACEMENT_NEW = 1; +//#define BT_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define BT_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef BT_USE_MEMCPY +// #include +// #include +// #endif //BT_USE_MEMCPY + +// #ifdef BT_USE_PLACEMENT_NEW +// #include +// Targeting ../BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java + + +// Targeting ../BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java + + +// Targeting ../BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java + + +// Targeting ../BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java + + + +// #endif //BT_OBJECT_ARRAY__ + + // Parsed from BulletCollision/BroadphaseCollision/btDbvt.h /* diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 0dd5aa6fd42..47e04e95a05 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -13,6 +13,7 @@ value = { @Platform( include = { + "LinearMath/btAlignedObjectArray.h", "BulletCollision/BroadphaseCollision/btDbvt.h", "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h", "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h", @@ -119,6 +120,20 @@ public void map(InfoMap infoMap) { .put(new Info("DBVT_INLINE").cppTypes().annotations()) .put(new Info("DBVT_CHECKTYPE").skip()) .put(new Info("BT_DECLARE_STACK_ONLY_OBJECT").cppText("#define BT_DECLARE_STACK_ONLY_OBJECT")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btCollisionObjectPointer")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btPersistentManifoldPointer")) + + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btQuantizedBvhNode")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) + + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btBvhSubtreeInfo")) + .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) + .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) + .put(new Info("btAlignedObjectArray::remove").skip()) ; } } From c1877f2fa49e60db708bdb9ab731bfdb8fe58e11 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 19 Feb 2022 23:43:31 +0800 Subject: [PATCH 17/81] Add sample simulating a piece of cloth Confirm working of BulletSoftBody bindings. --- bullet/samples/SimpleCloth.java | 91 +++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 bullet/samples/SimpleCloth.java diff --git a/bullet/samples/SimpleCloth.java b/bullet/samples/SimpleCloth.java new file mode 100644 index 00000000000..711b7d04391 --- /dev/null +++ b/bullet/samples/SimpleCloth.java @@ -0,0 +1,91 @@ +import org.bytedeco.javacpp.*; +import org.bytedeco.bullet.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import org.bytedeco.bullet.BulletSoftBody.*; +import org.bytedeco.bullet.LinearMath.*; + +public class SimpleCloth { + + private static btDefaultCollisionConfiguration m_collisionConfiguration; + private static btCollisionDispatcher m_dispatcher; + private static btBroadphaseInterface m_broadphase; + private static btConstraintSolver m_solver; + private static btSoftRigidDynamicsWorld m_dynamicsWorld; + private static btSoftBodyWorldInfo softBodyWorldInfo; + + public static void main(String[] args) { + createEmptyDynamicsWorld(); + + final float s = 4; //size of cloth patch + final int NUM_X = 31; //vertices on X axis + final int NUM_Z = 31; //vertices on Z axis + btSoftBody cloth = createSoftBody(s, NUM_X, NUM_Z, 1 + 2); + + for (int i = 0; i < 50; ++ i) + { + m_dynamicsWorld.stepSimulation(0.1f, 10, 0.01f); + btSoftBody.Face face = cloth.m_faces().at(1799); + btSoftBody.Node node = face.m_n(0); + btVector3 position = node.m_x(); + System.out.println(position.y()); + } + + System.out.println( + "\n" + + "This sample simulates a square piece of cloth (4 units of \n" + + "size in each dimension), with two corners fixed rigidly \n" + + "at the height of 5 units.\n" + + "At the beginning of the simulation, the cloth is positioned \n" + + "horizontally and, due to the presence of the gravity force, \n" + + "should proceed with a damped swinging motion. \n" + + "The numbers show the height at each simulation step of one \n" + + "of the free corners of the cloth. It should start around 5.0 \n" + + "and end up floating around 1.0.\n"); + } + + private static void createEmptyDynamicsWorld() + { + m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration(); + m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); + + m_broadphase = new btDbvtBroadphase(); + + m_solver = new btSequentialImpulseConstraintSolver(); + + m_dynamicsWorld = new btSoftRigidDynamicsWorld( + m_dispatcher, + m_broadphase, + m_solver, + m_collisionConfiguration); + m_dynamicsWorld.setGravity(new btVector3(0, -10, 0)); + + softBodyWorldInfo = new btSoftBodyWorldInfo(); + softBodyWorldInfo.m_broadphase(m_broadphase); + softBodyWorldInfo.m_dispatcher(m_dispatcher); + softBodyWorldInfo.m_gravity(m_dynamicsWorld.getGravity()); + softBodyWorldInfo.m_sparsesdf().Initialize(); + } + + public static btSoftBody createSoftBody( + float s, int numX, int numY, int fixed) + { + btSoftBody cloth = btSoftBodyHelpers.CreatePatch( + softBodyWorldInfo, + new btVector3(-s / 2, s + 1, 0), + new btVector3(+s / 2, s + 1, 0), + new btVector3(-s / 2, s + 1, +s), + new btVector3(+s / 2, s + 1, +s), + numX, numY, + fixed, true); + + cloth.getCollisionShape().setMargin(0.001f); + cloth.getCollisionShape().setUserPointer(cloth); + cloth.generateBendingConstraints(2, cloth.appendMaterial()); + cloth.setTotalMass(10); + cloth.m_cfg().piterations(5); + cloth.m_cfg().kDP(0.005f); + m_dynamicsWorld.addSoftBody(cloth); + + return cloth; + } +} From 2d970efe9223bbf06ce6609a7437cf59163a94a5 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 19 Feb 2022 23:51:00 +0800 Subject: [PATCH 18/81] Print message at the end of SimpleBox sample Explain how to interpret the output of the sample. --- bullet/samples/SimpleBox.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/bullet/samples/SimpleBox.java b/bullet/samples/SimpleBox.java index f841454b0b2..abda39ed675 100644 --- a/bullet/samples/SimpleBox.java +++ b/bullet/samples/SimpleBox.java @@ -39,6 +39,13 @@ public static void main(String[] args) btVector3 position = box.getWorldTransform().getOrigin(); System.out.println(position.y()); } + + System.out.println( + "\n" + + "This sample simulates falling of a rigid box, followed by \n" + + "an inelastic collision with a ground plane.\n" + + "The numbers show height of the box at each simulation step. \n" + + "It should start around 3.0 and end up around 1.0.\n"); } private static void createEmptyDynamicsWorld() From 1501c79aea93693177f75fc382de581baaa4e955 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sat, 19 Feb 2022 23:52:30 +0800 Subject: [PATCH 19/81] Remove specification of mainClass from sample's pom.xml There are multiple samples, each having its own main function. mainClass should be selected through the command line. --- bullet/samples/pom.xml | 1 - 1 file changed, 1 deletion(-) diff --git a/bullet/samples/pom.xml b/bullet/samples/pom.xml index 44f4537db36..c93b89de090 100644 --- a/bullet/samples/pom.xml +++ b/bullet/samples/pom.xml @@ -4,7 +4,6 @@ samples 1.5.7 - SimpleBox 1.7 1.7 From ddf2741cbf529ccc01ee67fe133cbda4ea755535 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 20 Feb 2022 15:33:57 +0800 Subject: [PATCH 20/81] README for bullet's preset --- bullet/README.md | 23 +++++++++++++++++++++++ bullet/samples/README.md | 4 ++++ 2 files changed, 27 insertions(+) create mode 100644 bullet/README.md create mode 100644 bullet/samples/README.md diff --git a/bullet/README.md b/bullet/README.md new file mode 100644 index 00000000000..3a762361c3e --- /dev/null +++ b/bullet/README.md @@ -0,0 +1,23 @@ +JavaCPP Presets for Bullet Physics SDK +====================================== + +Introduction +------------ +This directory contains the JavaCPP Presets module for: + + * Bullet Physics SDK 3.21 https://pybullet.org/wordpress + +Please refer to the parent README.md file for more detailed information about the JavaCPP Presets. + + +Documentation +------------- +Java API documentation is available here: + + * http://bytedeco.org/javacpp-presets/bullet/apidocs/ + + +Sample Usage +------------ + +See [bullet/samples/README.md]. diff --git a/bullet/samples/README.md b/bullet/samples/README.md new file mode 100644 index 00000000000..56afb1fcbde --- /dev/null +++ b/bullet/samples/README.md @@ -0,0 +1,4 @@ +To run any of the samples, run the following command: +```bash + $ mvn compile exec:java -Dexec.mainClass= +``` From dee5ebc5cba112644e0619d4b08736f95d463b24 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 21 Feb 2022 12:38:15 +0800 Subject: [PATCH 21/81] Skip methods with missing implementation --- .../BulletSoftBody/btDeformableBackwardEulerObjective.java | 2 +- .../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java | 2 +- .../main/java/org/bytedeco/bullet/presets/BulletSoftBody.java | 2 ++ 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java index 5e6ece957bb..4870b977671 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java @@ -52,7 +52,7 @@ public class btDeformableBackwardEulerObjective extends Pointer { public native @Cast("btScalar") float computeNorm(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual); // compute one step of the solve (there is only one solve if the system is linear) - public native void computeStep(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual, @Cast("const btScalar") float dt); + // perform A*x = b public native void multiply(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 b); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java index 98793147762..de09f8e6776 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java @@ -73,7 +73,7 @@ public class btDeformableMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld public native void performDeformableCollisionDetection(); - public native void solveMultiBodyConstraints(); + public native void solveContactConstraints(); diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 47bccb5a613..a7d2d6981e0 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -78,6 +78,7 @@ public void map(InfoMap infoMap) { ).skip()) .put(new Info("btDeformableMultiBodyDynamicsWorld::setSolverCallback").skip()) .put(new Info("btDeformableMultiBodyDynamicsWorld::rayTestSingle").skip()) + .put(new Info("btDeformableMultiBodyDynamicsWorld::solveMultiBodyConstraints").skip()) .put(new Info("btCPUVertexBufferDescriptor::getBufferType").skip()) .put(new Info("btSoftBodyVertexData").skip()) .put(new Info("btSoftBodyTriangleData").skip()) @@ -89,6 +90,7 @@ public void map(InfoMap infoMap) { .put(new Info("btDeformableBackwardEulerObjective::m_massPreconditioner").skip()) .put(new Info("btDeformableBackwardEulerObjective::m_KKTPreconditioner").skip()) .put(new Info("btDeformableBackwardEulerObjective::m_projection").skip()) + .put(new Info("btDeformableBackwardEulerObjective::computeStep").skip()) .put(new Info("btDeformableLagrangianForce::m_nodes").skip()) .put(new Info("btDeformableLagrangianForce::setIndices").skip()) From cc3eaa13bb07acd49cdfe2a593ee4ddfc85e60d5 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 21 Feb 2022 23:06:24 +0800 Subject: [PATCH 22/81] Build bullet preset on android platforms --- bullet/cppbuild.sh | 106 ++++++++++++++++++++++++++++++++++++++-- bullet/platform/pom.xml | 32 ++++++++++++ pom.xml | 4 ++ 3 files changed, 137 insertions(+), 5 deletions(-) diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh index 8b819a1e765..e6d96d19bbe 100755 --- a/bullet/cppbuild.sh +++ b/bullet/cppbuild.sh @@ -18,11 +18,108 @@ INSTALL_PATH=`pwd` echo "Decompressing archives..." unzip -qo ../bullet-$BULLET_VERSION.zip +cd bullet3-$BULLET_VERSION +[ -d .build ] || mkdir .build +cd .build + case $PLATFORM in + android-arm) + cmake \ + -DANDROID_ABI=armeabi-v7a \ + -DANDROID_NATIVE_API_LEVEL=24 \ + -DBUILD_BULLET2_DEMOS=OFF \ + -DBUILD_CLSOCKET=OFF \ + -DBUILD_CPU_DEMOS=OFF \ + -DBUILD_EGL=OFF \ + -DBUILD_ENET=OFF \ + -DBUILD_EXTRAS=OFF \ + -DBUILD_OPENGL3_DEMOS=OFF \ + -DBUILD_SHARED_LIBS=ON \ + -DBUILD_UNIT_TESTS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH \ + -DCMAKE_TOOLCHAIN_FILE=${PLATFORM_ROOT}/build/cmake/android.toolchain.cmake \ + -DENABLE_VHACD=OFF \ + -DUSE_DOUBLE_PRECISION=OFF \ + -DUSE_GLUT=OFF \ + -DUSE_GRAPHICAL_BENCHMARK=OFF \ + .. + make -j $MAKEJ + make install/strip + ;; + android-arm64) + cmake \ + -DANDROID_ABI=arm64-v8a \ + -DANDROID_NATIVE_API_LEVEL=24 \ + -DBUILD_BULLET2_DEMOS=OFF \ + -DBUILD_CLSOCKET=OFF \ + -DBUILD_CPU_DEMOS=OFF \ + -DBUILD_EGL=OFF \ + -DBUILD_ENET=OFF \ + -DBUILD_EXTRAS=OFF \ + -DBUILD_OPENGL3_DEMOS=OFF \ + -DBUILD_SHARED_LIBS=ON \ + -DBUILD_UNIT_TESTS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH \ + -DCMAKE_TOOLCHAIN_FILE=${PLATFORM_ROOT}/build/cmake/android.toolchain.cmake \ + -DENABLE_VHACD=OFF \ + -DUSE_DOUBLE_PRECISION=OFF \ + -DUSE_GLUT=OFF \ + -DUSE_GRAPHICAL_BENCHMARK=OFF \ + .. + make -j $MAKEJ + make install/strip + ;; + android-x86) + cmake \ + -DANDROID_ABI=x86 \ + -DANDROID_NATIVE_API_LEVEL=24 \ + -DBUILD_BULLET2_DEMOS=OFF \ + -DBUILD_CLSOCKET=OFF \ + -DBUILD_CPU_DEMOS=OFF \ + -DBUILD_EGL=OFF \ + -DBUILD_ENET=OFF \ + -DBUILD_EXTRAS=OFF \ + -DBUILD_OPENGL3_DEMOS=OFF \ + -DBUILD_SHARED_LIBS=ON \ + -DBUILD_UNIT_TESTS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH \ + -DCMAKE_TOOLCHAIN_FILE=${PLATFORM_ROOT}/build/cmake/android.toolchain.cmake \ + -DENABLE_VHACD=OFF \ + -DUSE_DOUBLE_PRECISION=OFF \ + -DUSE_GLUT=OFF \ + -DUSE_GRAPHICAL_BENCHMARK=OFF \ + .. + make -j $MAKEJ + make install/strip + ;; + android-x86_64) + cmake \ + -DANDROID_ABI=x86_64 \ + -DANDROID_NATIVE_API_LEVEL=24 \ + -DBUILD_BULLET2_DEMOS=OFF \ + -DBUILD_CLSOCKET=OFF \ + -DBUILD_CPU_DEMOS=OFF \ + -DBUILD_EGL=OFF \ + -DBUILD_ENET=OFF \ + -DBUILD_EXTRAS=OFF \ + -DBUILD_OPENGL3_DEMOS=OFF \ + -DBUILD_SHARED_LIBS=ON \ + -DBUILD_UNIT_TESTS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH \ + -DCMAKE_TOOLCHAIN_FILE=${PLATFORM_ROOT}/build/cmake/android.toolchain.cmake \ + -DENABLE_VHACD=OFF \ + -DUSE_DOUBLE_PRECISION=OFF \ + -DUSE_GLUT=OFF \ + -DUSE_GRAPHICAL_BENCHMARK=OFF \ + .. + make -j $MAKEJ + make install/strip + ;; linux-x86_64) - cd bullet3-$BULLET_VERSION - [ -d .build ] || mkdir .build - cd .build cmake \ -DBUILD_BULLET2_DEMOS=OFF \ -DBUILD_CLSOCKET=OFF \ @@ -42,11 +139,10 @@ case $PLATFORM in .. make -j $MAKEJ make install/strip - cd ../.. ;; *) echo "Error: Platform \"$PLATFORM\" is not supported" ;; esac -cd .. +cd ../../.. diff --git a/bullet/platform/pom.xml b/bullet/platform/pom.xml index 071bc3bc328..072281cd5e1 100644 --- a/bullet/platform/pom.xml +++ b/bullet/platform/pom.xml @@ -30,6 +30,30 @@ ${javacpp.moduleId} ${project.version} + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.android-arm} + + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.android-arm64} + + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.android-x86} + + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.android-x86_64} + ${project.groupId} ${javacpp.moduleId} @@ -50,6 +74,10 @@ ${javacpp.moduleId}.jar + ${javacpp.moduleId}-android-arm.jar + ${javacpp.moduleId}-android-arm64.jar + ${javacpp.moduleId}-android-x86.jar + ${javacpp.moduleId}-android-x86_64.jar ${javacpp.moduleId}-linux-x86_64.jar @@ -96,6 +124,10 @@ ${project.build.directory}/${project.artifactId}.jar module org.bytedeco.${javacpp.moduleId}.platform { + requires static org.bytedeco.${javacpp.moduleId}.android.arm; + requires static org.bytedeco.${javacpp.moduleId}.android.arm64; + requires static org.bytedeco.${javacpp.moduleId}.android.x86; + requires static org.bytedeco.${javacpp.moduleId}.android.x86_64; requires static org.bytedeco.${javacpp.moduleId}.linux.x86_64; } diff --git a/pom.xml b/pom.xml index 7be8eccacbe..875079b4863 100644 --- a/pom.xml +++ b/pom.xml @@ -779,6 +779,7 @@ tesseract tensorflow cpu_features + bullet ${javacpp.platform.library.path} @@ -828,6 +829,7 @@ tesseract tensorflow cpu_features + bullet ${javacpp.platform.library.path} @@ -877,6 +879,7 @@ tesseract tensorflow cpu_features + bullet ${javacpp.platform.library.path} @@ -926,6 +929,7 @@ tesseract tensorflow cpu_features + bullet ${javacpp.platform.library.path} From 3a2ce1b1924768a35b68429335ed48a4e65edc03 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 22 Feb 2022 00:31:00 +0800 Subject: [PATCH 23/81] Build bullet preset on windows platforms --- bullet/cppbuild.sh | 26 +++++++++++++ bullet/platform/pom.xml | 16 ++++++++ .../bullet/LinearMath/btInfMaskConverter.java | 37 ------------------- .../bytedeco/bullet/global/LinearMath.java | 12 +++++- .../bytedeco/bullet/presets/LinearMath.java | 1 + pom.xml | 2 + 6 files changed, 55 insertions(+), 39 deletions(-) delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btInfMaskConverter.java diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh index e6d96d19bbe..32406284db9 100755 --- a/bullet/cppbuild.sh +++ b/bullet/cppbuild.sh @@ -140,6 +140,32 @@ case $PLATFORM in make -j $MAKEJ make install/strip ;; + windows-x86|windows-x86_64) + export CC="cl.exe" + export CXX="cl.exe" + cmake \ + -G "Ninja" \ + -DBUILD_BULLET2_DEMOS=OFF \ + -DBUILD_CLSOCKET=OFF \ + -DBUILD_CPU_DEMOS=OFF \ + -DBUILD_EGL=OFF \ + -DBUILD_ENET=OFF \ + -DBUILD_EXTRAS=OFF \ + -DBUILD_OPENGL3_DEMOS=OFF \ + -DBUILD_SHARED_LIBS=OFF \ + -DBUILD_UNIT_TESTS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH \ + -DENABLE_VHACD=OFF \ + -DINSTALL_LIBS=ON \ + -DUSE_DOUBLE_PRECISION=OFF \ + -DUSE_GLUT=OFF \ + -DUSE_GRAPHICAL_BENCHMARK=OFF \ + -DUSE_MSVC_RUNTIME_LIBRARY_DLL=ON \ + .. + ninja -j $MAKEJ + ninja install + ;; *) echo "Error: Platform \"$PLATFORM\" is not supported" ;; diff --git a/bullet/platform/pom.xml b/bullet/platform/pom.xml index 072281cd5e1..66826c88ac2 100644 --- a/bullet/platform/pom.xml +++ b/bullet/platform/pom.xml @@ -60,6 +60,18 @@ ${project.version} ${javacpp.platform.linux-x86_64} + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.windows-x86} + + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.windows-x86_64} + @@ -79,6 +91,8 @@ ${javacpp.moduleId}-android-x86.jar ${javacpp.moduleId}-android-x86_64.jar ${javacpp.moduleId}-linux-x86_64.jar + ${javacpp.moduleId}-windows-x86.jar + ${javacpp.moduleId}-windows-x86_64.jar @@ -129,6 +143,8 @@ requires static org.bytedeco.${javacpp.moduleId}.android.x86; requires static org.bytedeco.${javacpp.moduleId}.android.x86_64; requires static org.bytedeco.${javacpp.moduleId}.linux.x86_64; + requires static org.bytedeco.${javacpp.moduleId}.windows.x86; + requires static org.bytedeco.${javacpp.moduleId}.windows.x86_64; } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btInfMaskConverter.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btInfMaskConverter.java deleted file mode 100644 index d76a2641363..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btInfMaskConverter.java +++ /dev/null @@ -1,37 +0,0 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.LinearMath; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; - -import static org.bytedeco.bullet.global.LinearMath.*; - -// #endif - -// #ifdef BT_USE_SSE -// #endif //BT_USE_SSE - -// #if defined(BT_USE_SSE) -// #else//BT_USE_SSE - -// #ifdef BT_USE_NEON -// #else //BT_USE_NEON - -// #ifndef BT_INFINITY - @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btInfMaskConverter extends Pointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btInfMaskConverter(Pointer p) { super(p); } - - public native float mask(); public native btInfMaskConverter mask(float setter); - public native int intmask(); public native btInfMaskConverter intmask(int setter); - public btInfMaskConverter(int _mask/*=0x7F800000*/) { super((Pointer)null); allocate(_mask); } - private native void allocate(int _mask/*=0x7F800000*/); - public btInfMaskConverter() { super((Pointer)null); allocate(); } - private native void allocate(); - } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index 7ea149d4141..81a84610edf 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -120,10 +120,18 @@ public class LinearMath extends org.bytedeco.bullet.presets.LinearMath { // #else //keep BT_LARGE_FLOAT*BT_LARGE_FLOAT < FLT_MAX public static final double BT_LARGE_FLOAT = 1e18f; -// Targeting ../LinearMath/btInfMaskConverter.java +// #endif + +// #ifdef BT_USE_SSE +// #endif //BT_USE_SSE + +// #if defined(BT_USE_SSE) +// #else//BT_USE_SSE +// #ifdef BT_USE_NEON +// #else //BT_USE_NEON - public static native @ByRef btInfMaskConverter btInfinityMask(); public static native void btInfinityMask(btInfMaskConverter setter); +// #ifndef BT_INFINITY // #define BT_INFINITY (btInfinityMask.mask) public static native int btGetInfinityMask(); // #endif diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index a9fb76b80a9..8a2cab7aa47 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -59,6 +59,7 @@ public void map(InfoMap infoMap) { .put(new Info("SIMD_EPSILON").skip()) .put(new Info("SIMD_INFINITY").skip()) .put(new Info("ATTRIBUTE_ALIGNED16").cppText("#define ATTRIBUTE_ALIGNED16(x) x")) + .put(new Info("btInfMaskConverter").skip()) // btVector3.h .put(new Info("BT_DECLARE_ALIGNED_ALLOCATOR").skip()) diff --git a/pom.xml b/pom.xml index 875079b4863..1b4902c6b6c 100644 --- a/pom.xml +++ b/pom.xml @@ -1590,6 +1590,7 @@ liquidfun cpu_features systems + bullet @@ -1671,6 +1672,7 @@ qt cpu_features systems + bullet From d571955f2eade7087e2f566d712bf6a19047b5c4 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 22 Feb 2022 23:28:11 +0800 Subject: [PATCH 24/81] Update version in bullet's `pom.xml` files to 1.5.8-SNAPSHOT --- bullet/platform/pom.xml | 2 +- bullet/pom.xml | 2 +- bullet/samples/pom.xml | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/bullet/platform/pom.xml b/bullet/platform/pom.xml index 66826c88ac2..c6a7cfae020 100644 --- a/bullet/platform/pom.xml +++ b/bullet/platform/pom.xml @@ -6,7 +6,7 @@ org.bytedeco javacpp-presets - 1.5.7 + 1.5.8-SNAPSHOT ../../ diff --git a/bullet/pom.xml b/bullet/pom.xml index 41dff83ca23..c737a868c60 100644 --- a/bullet/pom.xml +++ b/bullet/pom.xml @@ -6,7 +6,7 @@ org.bytedeco javacpp-presets - 1.5.7 + 1.5.8-SNAPSHOT org.bytedeco diff --git a/bullet/samples/pom.xml b/bullet/samples/pom.xml index c93b89de090..5a5f9108053 100644 --- a/bullet/samples/pom.xml +++ b/bullet/samples/pom.xml @@ -2,7 +2,7 @@ 4.0.0 org.bytedeco.bullet samples - 1.5.7 + 1.5.8-SNAPSHOT 1.7 1.7 @@ -11,7 +11,7 @@ org.bytedeco bullet-platform - 3.21-1.5.7 + 3.21-1.5.8-SNAPSHOT From c10cf96f363a75fbbc45a78f6ddc9542f829f5ab Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 22 Feb 2022 23:48:45 +0800 Subject: [PATCH 25/81] Replace tabs with spaces --- bullet/samples/SimpleBox.java | 12 +++++------ bullet/samples/SimpleCloth.java | 36 ++++++++++++++++----------------- 2 files changed, 24 insertions(+), 24 deletions(-) diff --git a/bullet/samples/SimpleBox.java b/bullet/samples/SimpleBox.java index abda39ed675..3942e465e73 100644 --- a/bullet/samples/SimpleBox.java +++ b/bullet/samples/SimpleBox.java @@ -23,15 +23,15 @@ public static void main(String[] args) createRigidBody(0, groundTransform, groundShape); - btBoxShape colShape = new btBoxShape(new btVector3(1, 1, 1)); + btBoxShape colShape = new btBoxShape(new btVector3(1, 1, 1)); float mass = 1.0f; colShape.calculateLocalInertia(mass, new btVector3(0, 0, 0)); - btTransform startTransform = new btTransform(); + btTransform startTransform = new btTransform(); startTransform.setIdentity(); - startTransform.setOrigin(new btVector3(0, 3, 0)); - btRigidBody box = createRigidBody(mass, startTransform, colShape); + startTransform.setOrigin(new btVector3(0, 3, 0)); + btRigidBody box = createRigidBody(mass, startTransform, colShape); for (int i = 0; i < 10; ++ i) { @@ -79,8 +79,8 @@ private static btRigidBody createRigidBody( btRigidBody body = new btRigidBody(cInfo); - body.setUserIndex(-1); - m_dynamicsWorld.addRigidBody(body); + body.setUserIndex(-1); + m_dynamicsWorld.addRigidBody(body); return body; } diff --git a/bullet/samples/SimpleCloth.java b/bullet/samples/SimpleCloth.java index 711b7d04391..e71ce650a07 100644 --- a/bullet/samples/SimpleCloth.java +++ b/bullet/samples/SimpleCloth.java @@ -11,15 +11,15 @@ public class SimpleCloth { private static btBroadphaseInterface m_broadphase; private static btConstraintSolver m_solver; private static btSoftRigidDynamicsWorld m_dynamicsWorld; - private static btSoftBodyWorldInfo softBodyWorldInfo; + private static btSoftBodyWorldInfo softBodyWorldInfo; public static void main(String[] args) { createEmptyDynamicsWorld(); - final float s = 4; //size of cloth patch - final int NUM_X = 31; //vertices on X axis - final int NUM_Z = 31; //vertices on Z axis - btSoftBody cloth = createSoftBody(s, NUM_X, NUM_Z, 1 + 2); + final float s = 4; //size of cloth patch + final int NUM_X = 31; //vertices on X axis + final int NUM_Z = 31; //vertices on Z axis + btSoftBody cloth = createSoftBody(s, NUM_X, NUM_Z, 1 + 2); for (int i = 0; i < 50; ++ i) { @@ -43,28 +43,28 @@ public static void main(String[] args) { "and end up floating around 1.0.\n"); } - private static void createEmptyDynamicsWorld() - { - m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration(); - m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); + private static void createEmptyDynamicsWorld() + { + m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration(); + m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); - m_broadphase = new btDbvtBroadphase(); + m_broadphase = new btDbvtBroadphase(); - m_solver = new btSequentialImpulseConstraintSolver(); + m_solver = new btSequentialImpulseConstraintSolver(); - m_dynamicsWorld = new btSoftRigidDynamicsWorld( + m_dynamicsWorld = new btSoftRigidDynamicsWorld( m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration); - m_dynamicsWorld.setGravity(new btVector3(0, -10, 0)); + m_dynamicsWorld.setGravity(new btVector3(0, -10, 0)); softBodyWorldInfo = new btSoftBodyWorldInfo(); - softBodyWorldInfo.m_broadphase(m_broadphase); - softBodyWorldInfo.m_dispatcher(m_dispatcher); - softBodyWorldInfo.m_gravity(m_dynamicsWorld.getGravity()); - softBodyWorldInfo.m_sparsesdf().Initialize(); - } + softBodyWorldInfo.m_broadphase(m_broadphase); + softBodyWorldInfo.m_dispatcher(m_dispatcher); + softBodyWorldInfo.m_gravity(m_dynamicsWorld.getGravity()); + softBodyWorldInfo.m_sparsesdf().Initialize(); + } public static btSoftBody createSoftBody( float s, int numX, int numY, int fixed) From d5a312cb7809150181e72a1e2fc5278bd3e324c6 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 22 Feb 2022 23:52:23 +0800 Subject: [PATCH 26/81] Fix link inside bullet/README.md --- bullet/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bullet/README.md b/bullet/README.md index 3a762361c3e..86a736cee9a 100644 --- a/bullet/README.md +++ b/bullet/README.md @@ -20,4 +20,4 @@ Java API documentation is available here: Sample Usage ------------ -See [bullet/samples/README.md]. +See [samples](samples). From c8f44c4c8270fcfa64a22a36a2128b1b9e951291 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 23 Feb 2022 11:56:09 +0800 Subject: [PATCH 27/81] Update JavaCPP version comment inside generated files of bullet preset --- .../bullet/BulletCollision/CalculateCombinedCallback.java | 2 +- .../bytedeco/bullet/BulletCollision/ContactAddedCallback.java | 2 +- .../bullet/BulletCollision/ContactDestroyedCallback.java | 2 +- .../bytedeco/bullet/BulletCollision/ContactEndedCallback.java | 2 +- .../bullet/BulletCollision/ContactProcessedCallback.java | 2 +- .../bytedeco/bullet/BulletCollision/ContactStartedCallback.java | 2 +- .../org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java | 2 +- .../bullet/BulletCollision/btActivatingCollisionAlgorithm.java | 2 +- .../BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java | 2 +- .../btAlignedObjectArray_btCollisionObjectPointer.java | 2 +- .../btAlignedObjectArray_btPersistentManifoldPointer.java | 2 +- .../btAlignedObjectArray_btQuantizedBvhNode.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btBoxShape.java | 2 +- .../bullet/BulletCollision/btBroadphaseAabbCallback.java | 2 +- .../bytedeco/bullet/BulletCollision/btBroadphaseInterface.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btBroadphasePair.java | 2 +- .../bullet/BulletCollision/btBroadphasePairSortPredicate.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java | 2 +- .../bullet/BulletCollision/btBroadphaseRayCallback.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java | 2 +- .../bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java | 2 +- .../bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCapsuleShape.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java | 2 +- .../bytedeco/bullet/BulletCollision/btCharIndexTripletData.java | 2 +- .../bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java | 2 +- .../BulletCollision/btCollisionAlgorithmConstructionInfo.java | 2 +- .../bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java | 2 +- .../bullet/BulletCollision/btCollisionConfiguration.java | 2 +- .../bytedeco/bullet/BulletCollision/btCollisionDispatcher.java | 2 +- .../bullet/BulletCollision/btCollisionDispatcherMt.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCollisionObject.java | 2 +- .../bullet/BulletCollision/btCollisionObjectDoubleData.java | 2 +- .../bullet/BulletCollision/btCollisionObjectFloatData.java | 2 +- .../bullet/BulletCollision/btCollisionObjectWrapper.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCollisionShape.java | 2 +- .../bytedeco/bullet/BulletCollision/btCollisionShapeData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCollisionWorld.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCompoundShape.java | 2 +- .../bytedeco/bullet/BulletCollision/btCompoundShapeChild.java | 2 +- .../bullet/BulletCollision/btCompoundShapeChildData.java | 2 +- .../bytedeco/bullet/BulletCollision/btCompoundShapeData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btConcaveShape.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btConeShape.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btConeShapeData.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btConstraintRow.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btConvexHullShape.java | 2 +- .../bytedeco/bullet/BulletCollision/btConvexHullShapeData.java | 2 +- .../BulletCollision/btConvexInternalAabbCachingShape.java | 2 +- .../bytedeco/bullet/BulletCollision/btConvexInternalShape.java | 2 +- .../bullet/BulletCollision/btConvexInternalShapeData.java | 2 +- .../bullet/BulletCollision/btConvexPenetrationDepthSolver.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btConvexShape.java | 2 +- .../bullet/BulletCollision/btConvexTriangleMeshShape.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCylinderShape.java | 2 +- .../bytedeco/bullet/BulletCollision/btCylinderShapeData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java | 2 +- .../gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java | 2 +- .../bullet/BulletCollision/btDefaultCollisionConfiguration.java | 2 +- .../BulletCollision/btDefaultCollisionConstructionInfo.java | 2 +- .../BulletCollision/btDiscreteCollisionDetectorInterface.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btDispatcher.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java | 2 +- .../gen/java/org/bytedeco/bullet/BulletCollision/btElement.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java | 2 +- .../gen/java/org/bytedeco/bullet/BulletCollision/btFace.java | 2 +- .../bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java | 2 +- .../bullet/BulletCollision/btHashedOverlappingPairCache.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btIntIndexData.java | 2 +- .../bullet/BulletCollision/btInternalTriangleIndexCallback.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btManifoldPoint.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btManifoldResult.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btMeshPartData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java | 2 +- .../bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btNearCallback.java | 2 +- .../bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btNullPairCache.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java | 2 +- .../bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java | 2 +- .../bullet/BulletCollision/btOptimizedBvhNodeFloatData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btOverlapCallback.java | 2 +- .../bullet/BulletCollision/btOverlapFilterCallback.java | 2 +- .../bytedeco/bullet/BulletCollision/btOverlappingPairCache.java | 2 +- .../bullet/BulletCollision/btOverlappingPairCallback.java | 2 +- .../bytedeco/bullet/BulletCollision/btPersistentManifold.java | 2 +- .../bullet/BulletCollision/btPersistentManifoldDoubleData.java | 2 +- .../bullet/BulletCollision/btPersistentManifoldFloatData.java | 2 +- .../BulletCollision/btPolyhedralConvexAabbCachingShape.java | 2 +- .../bullet/BulletCollision/btPolyhedralConvexShape.java | 2 +- .../bytedeco/bullet/BulletCollision/btPositionAndRadius.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java | 2 +- .../bullet/BulletCollision/btQuantizedBvhDoubleData.java | 2 +- .../bullet/BulletCollision/btQuantizedBvhFloatData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java | 2 +- .../bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java | 2 +- .../bullet/BulletCollision/btScaledBvhTriangleMeshShape.java | 2 +- .../bullet/BulletCollision/btScaledTriangleMeshShapeData.java | 2 +- .../bytedeco/bullet/BulletCollision/btShortIntIndexData.java | 2 +- .../bullet/BulletCollision/btShortIntIndexTripletData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java | 2 +- .../bullet/BulletCollision/btSimpleBroadphaseProxy.java | 2 +- .../bullet/BulletCollision/btSimplexSolverInterface.java | 2 +- .../bullet/BulletCollision/btSimulationIslandManager.java | 2 +- .../bullet/BulletCollision/btSortedOverlappingPairCache.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btSphereShape.java | 2 +- .../BulletCollision/btSphereSphereCollisionAlgorithm.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java | 2 +- .../bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btStorageResult.java | 2 +- .../bullet/BulletCollision/btStridingMeshInterface.java | 2 +- .../bullet/BulletCollision/btStridingMeshInterfaceData.java | 2 +- .../bullet/BulletCollision/btSubSimplexClosestResult.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btTriangleCallback.java | 2 +- .../bullet/BulletCollision/btTriangleIndexVertexArray.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btTriangleInfo.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java | 2 +- .../bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btTriangleMesh.java | 2 +- .../bytedeco/bullet/BulletCollision/btTriangleMeshShape.java | 2 +- .../bullet/BulletCollision/btTriangleMeshShapeData.java | 2 +- .../bytedeco/bullet/BulletCollision/btUniformScalingShape.java | 2 +- .../java/org/bytedeco/bullet/BulletCollision/btUnionFind.java | 2 +- .../org/bytedeco/bullet/BulletCollision/btUsageBitfield.java | 2 +- .../bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btActionInterface.java | 2 +- .../bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java | 2 +- .../java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java | 2 +- .../bytedeco/bullet/BulletDynamics/btBatchedConstraints.java | 2 +- .../bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java | 2 +- .../bullet/BulletDynamics/btConeTwistConstraintData.java | 2 +- .../bullet/BulletDynamics/btConeTwistConstraintDoubleData.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java | 2 +- .../bullet/BulletDynamics/btConstraintSolverPoolMt.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java | 2 +- .../bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java | 2 +- .../bullet/BulletDynamics/btContactSolverInfoDoubleData.java | 2 +- .../bullet/BulletDynamics/btContactSolverInfoFloatData.java | 2 +- .../bullet/BulletDynamics/btDefaultVehicleRaycaster.java | 2 +- .../bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java | 2 +- .../bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java | 2 +- .../bullet/BulletDynamics/btDynamicsWorldDoubleData.java | 2 +- .../bullet/BulletDynamics/btDynamicsWorldFloatData.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btGearConstraint.java | 2 +- .../bullet/BulletDynamics/btGearConstraintDoubleData.java | 2 +- .../bullet/BulletDynamics/btGearConstraintFloatData.java | 2 +- .../bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java | 2 +- .../bullet/BulletDynamics/btGeneric6DofConstraintData.java | 2 +- .../BulletDynamics/btGeneric6DofConstraintDoubleData2.java | 2 +- .../bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java | 2 +- .../BulletDynamics/btGeneric6DofSpring2ConstraintData.java | 2 +- .../btGeneric6DofSpring2ConstraintDoubleData2.java | 2 +- .../bullet/BulletDynamics/btGeneric6DofSpringConstraint.java | 2 +- .../BulletDynamics/btGeneric6DofSpringConstraintData.java | 2 +- .../btGeneric6DofSpringConstraintDoubleData2.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java | 2 +- .../BulletDynamics/btHingeAccumulatedAngleConstraint.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java | 2 +- .../bullet/BulletDynamics/btHingeConstraintDoubleData.java | 2 +- .../bullet/BulletDynamics/btHingeConstraintDoubleData2.java | 2 +- .../bullet/BulletDynamics/btHingeConstraintFloatData.java | 2 +- .../bytedeco/bullet/BulletDynamics/btInternalTickCallback.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btJointFeedback.java | 2 +- .../java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java | 2 +- .../bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java | 2 +- .../bullet/BulletDynamics/btMultiBodyConstraintSolver.java | 2 +- .../bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java | 2 +- .../bullet/BulletDynamics/btMultiBodyDynamicsWorld.java | 2 +- .../bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java | 2 +- .../bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java | 2 +- .../bullet/BulletDynamics/btMultiBodyJointFeedback.java | 2 +- .../bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java | 2 +- .../BulletDynamics/btMultiBodyLinkColliderDoubleData.java | 2 +- .../bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java | 2 +- .../bullet/BulletDynamics/btMultiBodyLinkDoubleData.java | 2 +- .../bullet/BulletDynamics/btMultiBodyLinkFloatData.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java | 2 +- .../bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java | 2 +- .../BulletDynamics/btPoint2PointConstraintDoubleData.java | 2 +- .../BulletDynamics/btPoint2PointConstraintDoubleData2.java | 2 +- .../bullet/BulletDynamics/btPoint2PointConstraintFloatData.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java | 2 +- .../java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java | 2 +- .../bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java | 2 +- .../bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java | 2 +- .../bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java | 2 +- .../bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java | 2 +- .../BulletDynamics/btSequentialImpulseConstraintSolver.java | 2 +- .../BulletDynamics/btSequentialImpulseConstraintSolverMt.java | 2 +- .../bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java | 2 +- .../bullet/BulletDynamics/btSimulationIslandManagerMt.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java | 2 +- .../bytedeco/bullet/BulletDynamics/btSliderConstraintData.java | 2 +- .../bullet/BulletDynamics/btSliderConstraintDoubleData.java | 2 +- .../bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java | 2 +- .../java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java | 2 +- .../bullet/BulletDynamics/btTranslationalLimitMotor.java | 2 +- .../bullet/BulletDynamics/btTranslationalLimitMotor2.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java | 2 +- .../bytedeco/bullet/BulletDynamics/btTypedConstraintData.java | 2 +- .../bullet/BulletDynamics/btTypedConstraintDoubleData.java | 2 +- .../bullet/BulletDynamics/btTypedConstraintFloatData.java | 2 +- .../bytedeco/bullet/BulletDynamics/btUniversalConstraint.java | 2 +- .../org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java | 2 +- .../java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java | 2 +- .../bullet/BulletDynamics/btWheelInfoConstructionInfo.java | 2 +- .../bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java | 2 +- .../BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java | 2 +- .../btAlignedObjectArray_btSoftBody_ClusterPointer.java | 2 +- .../BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java | 2 +- .../btAlignedObjectArray_btSoftBody_JointPointer.java | 2 +- .../BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java | 2 +- .../btAlignedObjectArray_btSoftBody_MaterialPointer.java | 2 +- .../BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java | 2 +- .../BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java | 2 +- .../btAlignedObjectArray_btSoftBody_RContact.java | 2 +- .../btAlignedObjectArray_btSoftBody_RenderFace.java | 2 +- .../btAlignedObjectArray_btSoftBody_RenderNode.java | 2 +- .../btAlignedObjectArray_btSoftBody_SContact.java | 2 +- .../BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java | 2 +- .../bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java | 2 +- .../bullet/BulletSoftBody/btCollisionObjectWrapper.java | 2 +- .../BulletSoftBody/btDeformableBackwardEulerObjective.java | 2 +- .../bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java | 2 +- .../bullet/BulletSoftBody/btDeformableLagrangianForce.java | 2 +- .../BulletSoftBody/btDeformableMultiBodyConstraintSolver.java | 2 +- .../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java | 2 +- .../gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java | 2 +- .../org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java | 2 +- .../btSoftBodyRigidBodyCollisionConfiguration.java | 2 +- .../org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java | 2 +- .../bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java | 2 +- .../org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java | 2 +- .../bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java | 2 +- .../bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java | 2 +- .../java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java | 2 +- .../bullet/BulletSoftBody/btVertexBufferDescriptor.java | 2 +- .../gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java | 2 +- .../bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java | 2 +- .../bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java | 2 +- .../bullet/LinearMath/btAlignedObjectArray_btQuaternion.java | 2 +- .../bullet/LinearMath/btAlignedObjectArray_btScalar.java | 2 +- .../bullet/LinearMath/btAlignedObjectArray_btVector3.java | 2 +- .../bullet/LinearMath/btAlignedObjectArray_btVector4.java | 2 +- .../bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java | 2 +- .../bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java | 2 +- bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java | 2 +- bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java | 2 +- bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java | 2 +- .../org/bytedeco/bullet/LinearMath/btDefaultMotionState.java | 2 +- .../org/bytedeco/bullet/LinearMath/btDefaultSerializer.java | 2 +- .../org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java | 2 +- .../src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java | 2 +- .../bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java | 2 +- .../src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btHashString.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java | 2 +- .../org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java | 2 +- .../org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java | 2 +- .../org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java | 2 +- .../java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java | 2 +- .../src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java | 2 +- .../org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java | 2 +- .../org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java | 2 +- .../org/bytedeco/bullet/LinearMath/btSpatialForceVector.java | 2 +- .../org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java | 2 +- .../bullet/LinearMath/btSpatialTransformationMatrix.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java | 2 +- .../org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btTransform.java | 2 +- .../org/bytedeco/bullet/LinearMath/btTransformDoubleData.java | 2 +- .../org/bytedeco/bullet/LinearMath/btTransformFloatData.java | 2 +- .../gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java | 2 +- .../src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java | 2 +- .../org/bytedeco/bullet/LinearMath/btVector3DoubleData.java | 2 +- .../java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java | 2 +- .../src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java | 2 +- .../gen/java/org/bytedeco/bullet/global/BulletCollision.java | 2 +- .../src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java | 2 +- .../src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java | 2 +- bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java | 2 +- 306 files changed, 306 insertions(+), 306 deletions(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/CalculateCombinedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/CalculateCombinedCallback.java index d7a93ed6414..64a53b3fae3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/CalculateCombinedCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/CalculateCombinedCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactAddedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactAddedCallback.java index d615d66965d..48204a4e368 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactAddedCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactAddedCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactDestroyedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactDestroyedCallback.java index 31b40bc2ff1..117b07f647a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactDestroyedCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactDestroyedCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactEndedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactEndedCallback.java index 78acc7bf2c1..d8a08b70005 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactEndedCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactEndedCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactProcessedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactProcessedCallback.java index b97fb675d73..b0ceef04958 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactProcessedCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactProcessedCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactStartedCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactStartedCallback.java index da40d99f434..80166b1d56c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactStartedCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ContactStartedCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java index f24920233c0..4ea65cc172a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/bt32BitAxisSweep3.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btActivatingCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btActivatingCollisionAlgorithm.java index 5a170db9473..99e3c747ea5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btActivatingCollisionAlgorithm.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btActivatingCollisionAlgorithm.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java index fb233600d55..04410534c19 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java index cee54898d6c..57b84cbed6b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java index 0f13952aeaa..7613187434e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java index 8a41d401c3c..a09c96292d8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java index 0c13b2c4c6b..39e6c9014cc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAxisSweep3.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java index 1050b973760..66a90c50d7b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBU_Simplex1to4.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxShape.java index c9ede4a4286..2a8f52fe901 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseAabbCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseAabbCallback.java index a14ba40e547..8ec6ee3c0e4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseAabbCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseAabbCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseInterface.java index e92763d70e1..ca8518383a4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseInterface.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePair.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePair.java index 96acf94eb0a..a131a5482b0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePair.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePair.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePairSortPredicate.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePairSortPredicate.java index b416376c299..2f5a4a109ce 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePairSortPredicate.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphasePairSortPredicate.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java index 0945c1b2191..a484f0f61c0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseProxy.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseRayCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseRayCallback.java index 7ab609e555a..15b408dc5a9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseRayCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBroadphaseRayCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java index e057cd099dd..15f2b45bc3b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java index da53fd54ee6..cc50fca55ef 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java index 99306076b37..caf56eb3c65 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTriangleMeshShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShape.java index c217a84068e..d27048283cd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java index de776202576..152e92d830e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java index a11d7b0a150..85f28e7932c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeX.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java index c713091c21f..3faa746dde5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCapsuleShapeZ.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCharIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCharIndexTripletData.java index 7be9141450a..a4ad2a67ceb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCharIndexTripletData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCharIndexTripletData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java index a35d84e6ad3..6dcf7d7e95b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java index 4af5c58a250..f3ed93497d3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmConstructionInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java index 52e5e0675f3..e1f04bc963c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithmCreateFunc.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java index 88061089730..a83070b5afc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionConfiguration.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcher.java index c91feab9ebe..9515743437d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcher.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcher.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcherMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcherMt.java index 7286a440839..683b923616c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcherMt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionDispatcherMt.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObject.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObject.java index 4ea0d122d89..df6fc8dba8e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObject.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObject.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectDoubleData.java index 0b3d564db12..c68d92687d4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectFloatData.java index 81adb3f9edb..c3be97c0c62 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java index b2169399148..0ad1ce6da23 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShape.java index 5175acacba8..3451f83ae3c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShapeData.java index a3e641c68ec..8d7a52a58b3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java index 8a5b866617f..ab623077445 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShape.java index e412d5f78be..81a1f89f4fa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java index 2980287d26f..e5eaab60655 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChildData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChildData.java index 5b29c028bf0..a042a15595a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChildData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChildData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeData.java index f5d389ff024..236bf163020 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConcaveShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConcaveShape.java index 49f1b0d76d2..f94e96dec85 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConcaveShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConcaveShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShape.java index 165c5e090be..5f3c0d5f8ce 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeData.java index b76913cc4b5..b62ada30776 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java index 10513ae4824..c8b57408402 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeX.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java index 4e2456460e5..60fce729610 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeShapeZ.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConstraintRow.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConstraintRow.java index 08c30af6b4c..7924d9c9c5b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConstraintRow.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConstraintRow.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShape.java index e97cfc744ab..11f50c7e14d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShapeData.java index 1c756c00a7d..5779ee6bc88 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexHullShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalAabbCachingShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalAabbCachingShape.java index c6720faa1c3..2ab467cab47 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalAabbCachingShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalAabbCachingShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShape.java index da372055024..95ac9d1ad5a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShapeData.java index e70defb2908..3ed5cbff5ec 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexInternalShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java index d33933dbc34..7ed70b3630d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPenetrationDepthSolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java index 52be4eabd9e..27af221fcf0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java index 36934a041ec..0e45e1942ae 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleMeshShape.java index e6b11e02428..d2b738569ff 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleMeshShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleMeshShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShape.java index 83d6b8af3c8..f86739449de 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeData.java index 0ea4e148f84..000b1baeb97 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java index e9e8b8b089a..dd4aea03987 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeX.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java index e0fade73973..d7e0109a9dc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCylinderShapeZ.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java index 44c1154d25a..d02ca8fb943 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvntNode.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java index 950983f4409..39fec13ef3e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java index 9077e3de9c6..121e34fba75 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtAabbMm.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java index c8bcce8f40b..3ecde0a69a4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java index a33f59917c0..5b7d004abf5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtNode.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConfiguration.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConfiguration.java index c7ce640e14e..59c424ba222 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConfiguration.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConfiguration.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConstructionInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConstructionInfo.java index 94e676c5b95..6b8e6f85b4a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConstructionInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDefaultCollisionConstructionInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDiscreteCollisionDetectorInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDiscreteCollisionDetectorInterface.java index f9f8409a6b2..155f236a048 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDiscreteCollisionDetectorInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDiscreteCollisionDetectorInterface.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcher.java index 429cbe5867c..ee0e4725fba 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcher.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcher.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java index e44f62f85c0..2e973a903e3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDispatcherInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btElement.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btElement.java index 7d307cf50f7..bce77a8ef2b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btElement.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btElement.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java index 2f97f475293..7c2dda53fec 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java index 16780549af7..64d2a4ca494 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java index 560cb1d2958..f529a6e1c87 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaPenetrationDepthSolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java index 51b8ec8b8e0..8859bbd113f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java index 903a74df0b7..7e407251470 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMesh.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIntIndexData.java index c9021563f72..efaf0e120ad 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIntIndexData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIntIndexData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btInternalTriangleIndexCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btInternalTriangleIndexCallback.java index 9e6907832bc..0159d3c3c04 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btInternalTriangleIndexCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btInternalTriangleIndexCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldPoint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldPoint.java index 72ac49fad56..988ff2e768a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldPoint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldPoint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldResult.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldResult.java index 0a39b5db75e..1c828a8c9f6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldResult.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btManifoldResult.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMeshPartData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMeshPartData.java index 18a80238dd0..225be28729a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMeshPartData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMeshPartData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java index 5748291e1ef..22c9fdd7e37 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java index 408356de9a2..9e907d876bb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiSphereShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNearCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNearCallback.java index d3fc7a375c6..77969a9704c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNearCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNearCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java index 28883f108d4..63f458e4ff5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNodeOverlapCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java index 4932bf1ef00..abeab943a01 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java index 21204079fe6..13156c852b8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvh.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java index e304555cba2..1eb9eb41ae5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNode.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java index e4f8ad98a44..f10f20a29e5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeFloatData.java index 116c2484c04..58a5029250e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOptimizedBvhNodeFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapCallback.java index f4785d06802..9caeaacdb9c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapFilterCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapFilterCallback.java index 0cfb2441a76..7938d9f881e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapFilterCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlapFilterCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java index 5f53ea6ec51..ed3f78483bc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCallback.java index 271e01a2d25..cb108db331e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java index 7bf939494a9..202f4cec57a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifold.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldDoubleData.java index ed2afa5d400..f9c062994db 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldFloatData.java index b2e3bc7333b..34b1808a2d4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexAabbCachingShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexAabbCachingShape.java index 0ea0f7c466f..17d654b02d0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexAabbCachingShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexAabbCachingShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexShape.java index bd16f2e3142..aee9d49f5fc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralConvexShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPositionAndRadius.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPositionAndRadius.java index b41afd2dd14..f409f3fd9b6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPositionAndRadius.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPositionAndRadius.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java index c79eeab1d76..4039f45b4ea 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhDoubleData.java index b00d9535f58..d8e4c2e9a05 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhFloatData.java index ff61cbbf1b3..e92309e73c9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java index 626914410cc..ed1ab292528 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNode.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java index 2d6399d3003..9211ec969ef 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledBvhTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledBvhTriangleMeshShape.java index 20a906bd77d..73ba2f2502f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledBvhTriangleMeshShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledBvhTriangleMeshShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledTriangleMeshShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledTriangleMeshShapeData.java index c76f733754a..856b0d82264 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledTriangleMeshShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btScaledTriangleMeshShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexData.java index 345e04aa21c..5fc89cb912a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexTripletData.java index 5707cdb79fb..ecf02db5f92 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexTripletData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShortIntIndexTripletData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java index fc2cfe0c4c8..98de8dc2390 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphase.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphaseProxy.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphaseProxy.java index ba5a618964f..44c023de8a7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphaseProxy.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimpleBroadphaseProxy.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplexSolverInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplexSolverInterface.java index 8ea2c18e9dd..a2477af2b48 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplexSolverInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplexSolverInterface.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimulationIslandManager.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimulationIslandManager.java index 3a83cc51cdc..98e8347f218 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimulationIslandManager.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimulationIslandManager.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java index 8f37fafe1d9..9d2f5ca1a6a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereShape.java index 6fc22da07ff..a9287d80523 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java index 5e055d2c3f8..ed5b28a26df 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java index b031c2e02d4..a53b37e897f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java index 7351f6a1fa0..199e9b061d9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStaticPlaneShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStorageResult.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStorageResult.java index 9dc58e180d0..bd9791106d2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStorageResult.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStorageResult.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterface.java index fd0f568f6e2..d767e1b34fb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterface.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterfaceData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterfaceData.java index a1d115d6142..a4f7dfc595f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterfaceData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btStridingMeshInterfaceData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubSimplexClosestResult.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubSimplexClosestResult.java index 4bcc76b326d..24702169ffd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubSimplexClosestResult.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubSimplexClosestResult.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleCallback.java index 568a9787f4c..311116c8e3b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java index 50aaf969d4b..65bb4d380af 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfo.java index f234d837919..a40658fb86e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java index e5673e41920..9f7d94ba639 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java index 701b9994c1f..2fe1363e882 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMap.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java index 7bbfe8ab9be..d42c0d557a5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleInfoMapData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMesh.java index a9297489cd7..556148c52d8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMesh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMesh.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShape.java index 67d240718a6..5951ae77216 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShapeData.java index a343ecf45a9..81598fe952e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShapeData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleMeshShapeData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUniformScalingShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUniformScalingShape.java index a31121ba7f9..8440a0c5290 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUniformScalingShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUniformScalingShape.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUnionFind.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUnionFind.java index 192aa8e34de..b0b3f94b68a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUnionFind.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUnionFind.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUsageBitfield.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUsageBitfield.java index b9fa6a7da12..f80d119b209 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUsageBitfield.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btUsageBitfield.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java index 69b2fefa79d..fdf3d90ce7e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btVoronoiSimplexSolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletCollision; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java index b90f2b48749..ce2104820c4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btActionInterface.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java index d708d3440d9..42d4b762c88 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java index 5a1c4bc726f..bb797bd11c7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAngularLimit.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java index 5a6353c0246..341411ff10d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java index d5b42e0e6c6..00e50fbfcdb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java index 95933f89e0d..d71dc2d7cb1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java index 81d2742cff5..88114fd0b2f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java index 211e0776b16..d637eaa1b91 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSetting.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java index e0bebb9bf22..283913b4a08 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolverPoolMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolverPoolMt.java index 36301f9f79c..8cc6279f67a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolverPoolMt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConstraintSolverPoolMt.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java index 7c85bea05f5..d4a09ce2bba 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java index 75d6105310f..a79196bd743 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoDoubleData.java index fae0e795640..5019dca4a4e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoFloatData.java index 45bed51079e..507991ae670 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactSolverInfoFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDefaultVehicleRaycaster.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDefaultVehicleRaycaster.java index 1de6e1524a6..790f2935e81 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDefaultVehicleRaycaster.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDefaultVehicleRaycaster.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java index ee87f215079..9786457d5d3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java index 11095ff7ae6..0ed23ff85c7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorldMt.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java index 01ec41b9fa5..773dfc95fd9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorld.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldDoubleData.java index 318ba38ca78..03ee28bec13 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldFloatData.java index c9146ed13a9..21aec68d0e5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDynamicsWorldFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java index 0a5748f6b19..a6322318069 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btFixedConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java index afbfa2b9265..e0f30118333 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java index bcddcd25f0b..c3af3208283 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java index a93bc81c742..8e7b42dc2ee 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java index 396c34c82d3..13ffc8f91d3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java index dfb2428d8f2..b8243da6352 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java index ff50cce2893..99e962eed4d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java index 9d02fbca08f..4f7bc231e17 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java index 314333500a4..8928a01e1a1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java index 231f7755403..c46e3799c46 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java index 0c1594613c2..60b35a38c8b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintData.java index 22efbf85a27..498cac065da 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java index 21b63560f8e..1d9ca02790b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java index f1bc6739c22..52a5260b20a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHinge2Constraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java index ae1a19613ee..9f9bf82d705 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java index 093ce92a820..56dff587c17 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java index f0abd3e99f2..a7498233ab7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java index b3f7aceb590..7be4cba1149 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java index 15f8119e78a..75ab8ba5aff 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btInternalTickCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btInternalTickCallback.java index e0375aea953..3894bf7e471 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btInternalTickCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btInternalTickCallback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJointFeedback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJointFeedback.java index 462c3e7cadd..e5ddb57b8ba 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJointFeedback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJointFeedback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java index 10439a00d83..8163fe32e86 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java index 0a173d36ffb..de36707dd5e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java index 9179efac02f..aa31ab8c2d8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintSolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java index 03db1342389..3bd786ab267 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java index d68f46f2da0..925678e79b7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java index b54ebbb32e9..78ade1c9aad 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java index 92b58d46a4b..960ff4af5ae 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointFeedback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointFeedback.java index 8d78d441600..14370a62af5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointFeedback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointFeedback.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java index 6b599d876fe..23ba99f46ae 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkCollider.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderDoubleData.java index ce5f3b65339..c5080ed4fc8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java index 8b7796cf58c..d0e32e8feda 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkColliderFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkDoubleData.java index acdfdaa82b1..86eabd92cbb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkFloatData.java index 0ab8fde2a3e..9c5d8bba324 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyLinkFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java index fff0debe7cf..463f77c4bb1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultibodyLink.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java index f79a449ff26..275cf6d19e0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java index e5abb8625d1..2b7b297ed29 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java index 01fd9de739f..1715c80adf7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java index c86d6d3e51c..a14e91762a7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java index cfe4aa9e536..9a93f8f39f4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java index a3167ed0c21..279e2b8d8b2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBody.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java index 1b07277a5b8..8f0cdede785 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java index 9dc5754dad3..1313690a246 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java index ff0bdda07a6..f77fb0d4419 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java index 3920f8b8137..85c060b6f51 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRotationalLimitMotor2.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java index 5c7931e8927..ddc6f2bf3b6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java index f5874bca158..32a5563bc25 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java index a58a6e3a062..9d66ac76e66 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimpleDynamicsWorld.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java index f1d4343362b..81bf9e92a04 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java index fb074bc3688..1855cab94e0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java index aec98f1a647..b2a789a690d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java index c99c43e7eb9..444d18dbbf6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java index c132189f24b..56a16b389fb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java index 6819c1d8b8e..ed862ceca19 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBody.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java index f909623a154..6cd4f01bf39 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor.java index b05c61be3d4..98e3a1bb016 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor2.java index e0477ded9bf..6d97b5db17e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTranslationalLimitMotor2.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java index eaa90fcc46d..329ddf46919 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintData.java index c3833e12c6a..0f1e28df3b2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintDoubleData.java index 41fb2875015..e03ac5f28f3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintFloatData.java index d6f836b1f68..353007fed07 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btUniversalConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btUniversalConstraint.java index 67befce5296..71aa5506671 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btUniversalConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btUniversalConstraint.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java index c877bc13fde..c03e7b848d9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btVehicleRaycaster.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java index 073201e13c4..2364084ecdc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoConstructionInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoConstructionInfo.java index 5331af21a80..66873d37d0f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoConstructionInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoConstructionInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletDynamics; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java index 90d26c237a0..7dc93bc43a1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java index 9ebbddb235b..39e11da8a26 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java index da390c271ec..08b7c72c5a8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java index ebd7166a960..798b768d58b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java index e8071a1415e..7845e39fa06 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java index b49ec8aeb1f..d611c8dd684 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java index e0609d4f749..7ee22d1fab3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java index 832f2b6610a..957249614b5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java index 8e31bc256bd..d1b43577ddc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java index 4313aee8a01..c95d6101c6f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java index 4f4199e9dd9..148064c9f62 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java index 9bdc4cbc2d3..da33e3ab40c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java index 1f4415f7f44..f0769df2fa3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java index ea931c39caf..136a4ef1d5d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java index f44f476bbc7..4d96ff16c51 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java index cf608afdc30..24776ff1606 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java index 4870b977671..2465d0f18cf 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java index 59d47845f87..6a1fa51feb0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java index 4c36907ef64..f5dfdc12f96 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.java index 73756490549..de3b2f3fc90 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyConstraintSolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java index de09f8e6776..30a0c6e8553 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java index 6d378b2679b..6d004ae06cd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java index aface4ee22e..aa260c90248 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyHelpers.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java index d2a90ee3176..580327c8778 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java index 50a47fe06ee..ca16e90eb13 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java index a99b2666836..dde2e0eeb5e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolverOutput.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java index 2946b41cf6f..88220cf2bbd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java index ec4f358fae3..c349396ca69 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java index cab662a89b5..0284a379fff 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java index ef7dae5c2f7..f849c4b1b1f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java index c04ce9a9965..8f897a9af2c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java index 4039b555268..b8866e8be3d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/fDrawFlags.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.BulletSoftBody; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java index 6a6744d215c..f41adf3911d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/CProfileSample.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java index 4b875125dc2..cd6d0720d74 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java index 2d0a5c4b5fc..3b6eea11f62 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java index 6724fbceb41..94e9398d9f6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java index 4ecdd43697b..c21e5427b38 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java index 81eb5f4fb55..723034a810d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java index d987b79ca65..4582a07f586 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java index fd94f356878..3216358252c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java index 6c6c8bf92d4..5f3a082c7ee 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java index a9c959a437f..4ec68f5fbbd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBlock.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java index 100f7d3e2ff..9f22b9a3f25 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btChunk.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java index 8e1c57f933d..692be296b07 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btClock.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultMotionState.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultMotionState.java index ef1b764476e..a8e406c088a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultMotionState.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultMotionState.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultSerializer.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultSerializer.java index 1af91e5ab92..b14fb8808b5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultSerializer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDefaultSerializer.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java index 989e0e8685d..e4a4dc4125c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btEnterProfileZoneFunc.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java index 45926a77d77..66e6b4a3ef2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashInt.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java index 3c5a723991b..f42436350f8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashPtr_voidPointer.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java index 5286d2c2b2f..c2a6409a8ff 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashPtr.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashString.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashString.java index 72a53b10b86..ae820262f46 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashString.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashString.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java index 7a753eb8f36..07ed98396b9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIDebugDraw.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java index a084c5f5031..985853b4f07 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btLeaveProfileZoneFunc.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java index 4c8bb815dd2..f7649eda1d7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java index 3b14b5935dc..71e0417c41d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3DoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java index 2a64ec59474..631d147fd62 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3FloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java index e0f630a61fa..e8d7b7a5441 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMotionState.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java index e22e16697b3..6f69f9a4a84 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPointerUid.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java index e56184df81b..4f7d44082c1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPoolAllocator.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java index 63ac9029b1e..6767ca10563 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuadWord.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java index c24956f76ba..2fec92fd3a1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternion.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java index da01d65ac5f..e1dd96ad3b9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java index 250b313356a..172d99c06bb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java index 720f1499c7b..ab29524bb5a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSerializer.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialForceVector.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialForceVector.java index 18526f3b442..3d1eaed7ef7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialForceVector.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialForceVector.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java index ff57213ae99..555d4c3ccad 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialMotionVector.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialTransformationMatrix.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialTransformationMatrix.java index 8fd06737c03..ec60475573c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialTransformationMatrix.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpatialTransformationMatrix.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java index 327318f6980..41bf534ecd5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btStackAlloc.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java index 04672e5d32f..306f619adaa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSymmetricSpatialDyad.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransform.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransform.java index cfcf79e5f23..290c81d8b51 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransform.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransform.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformDoubleData.java index c6baae1ec1a..6cbe467e604 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformDoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformFloatData.java index 54fea2bae28..21f448ac572 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformFloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java index 565d183a7d6..cfae9aac1bd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTypedObject.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java index 8ff22b11047..b8db96a4357 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3DoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3DoubleData.java index 30494587eff..a8d353aa0c8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3DoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3DoubleData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java index 0c543609465..5cadc28e164 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3FloatData.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java index 8b007f2dbb0..0033d137f24 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index b7726023c31..4d83f5f82aa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.global; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index 5d9f7a66a28..16183f1190e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.global; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index c2e44139e5b..22907061826 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.global; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index 81a84610edf..f7e838e96ff 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -1,4 +1,4 @@ -// Targeted by JavaCPP version 1.5.7: DO NOT EDIT THIS FILE +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE package org.bytedeco.bullet.global; From 1c058ca12c6d309faac802796ea176d6bb57bda3 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 23 Feb 2022 12:04:52 +0800 Subject: [PATCH 28/81] Github Actions workflow for bullet preset --- .github/workflows/bullet.yml | 63 ++++++++++++++++++++++++++++++++++++ 1 file changed, 63 insertions(+) create mode 100644 .github/workflows/bullet.yml diff --git a/.github/workflows/bullet.yml b/.github/workflows/bullet.yml new file mode 100644 index 00000000000..8b4d16b19a7 --- /dev/null +++ b/.github/workflows/bullet.yml @@ -0,0 +1,63 @@ +name: bullet +on: + push: + paths: + - bullet/** + pull_request: + paths: + - bullet/** + workflow_dispatch: +env: + CI_DEPLOY_MODULE: ${{ github.workflow }} + CI_DEPLOY_PLATFORM: ${{ github.job }} + CI_DEPLOY_SETTINGS: ${{ secrets.CI_DEPLOY_SETTINGS }} + CI_DEPLOY_USERNAME: ${{ secrets.CI_DEPLOY_USERNAME }} + CI_DEPLOY_PASSWORD: ${{ secrets.CI_DEPLOY_PASSWORD }} + STAGING_REPOSITORY: ${{ secrets.STAGING_REPOSITORY }} +jobs: + android-arm: + runs-on: ubuntu-18.04 + container: centos:7 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-centos@actions + android-arm64: + runs-on: ubuntu-18.04 + container: centos:7 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-centos@actions + android-x86: + runs-on: ubuntu-18.04 + container: centos:7 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-centos@actions + android-x86_64: + runs-on: ubuntu-18.04 + container: centos:7 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-centos@actions + linux-x86_64: + runs-on: ubuntu-18.04 + container: centos:7 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-centos@actions + windows-x86: + runs-on: windows-2019 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-windows@actions + windows-x86_64: + runs-on: windows-2019 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-windows@actions + redeploy: + needs: [ + android-arm, + android-arm64, + android-x86, + android-x86_64, + linux-x86_64, + windows-x86, + windows-x86_64 + ] + runs-on: ubuntu-18.04 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/redeploy@actions From f50c3a4cbe9bf9875995afea655e8e81e53422f8 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 23 Feb 2022 12:35:13 +0800 Subject: [PATCH 29/81] Copy licence from the bullet's repository --- bullet/LICENCE | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 bullet/LICENCE diff --git a/bullet/LICENCE b/bullet/LICENCE new file mode 100644 index 00000000000..319c84e349f --- /dev/null +++ b/bullet/LICENCE @@ -0,0 +1,15 @@ + +The files in this repository are licensed under the zlib license, except for the files under 'Extras' and examples/ThirdPartyLibs. + +Bullet Continuous Collision Detection and Physics Library +http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. From 19553d4a65fbb6f8434d894fc57365f75b0ef92f Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 23 Feb 2022 12:55:35 +0800 Subject: [PATCH 30/81] Mention bullet in the root README --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 3b6e04c553f..615fbfea5bc 100644 --- a/README.md +++ b/README.md @@ -233,6 +233,7 @@ Each child module in turn relies by default on the included [`cppbuild.sh` scrip * Linux (glibc) https://www.gnu.org/software/libc/ * Mac OS X (XNU libc) https://opensource.apple.com/ * Windows (Win32) https://developer.microsoft.com/en-us/windows/ + * Bullet Physics SDK 3.21 https://pybullet.org/wordpress Once everything installed and configured, simply execute ```bash From 50d72ce02dc13ecb74e6c626b9ba3631c97acd74 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 23 Feb 2022 14:30:48 +0800 Subject: [PATCH 31/81] Refactor bullet's preset classes Group similar mappings. --- ...btAlignedObjectArray_btBvhSubtreeInfo.java | 4 + ...dObjectArray_btCollisionObjectPointer.java | 4 - .../btTriangleIndexVertexArray.java | 2 +- .../bullet/global/BulletCollision.java | 6 +- .../bullet/global/BulletSoftBody.java | 26 +- .../bytedeco/bullet/global/LinearMath.java | 8 +- .../bullet/presets/BulletCollision.java | 92 ++++--- .../bullet/presets/BulletDynamics.java | 143 +++++----- .../bullet/presets/BulletSoftBody.java | 252 ++++++++---------- .../bytedeco/bullet/presets/LinearMath.java | 81 +++--- 10 files changed, 294 insertions(+), 324 deletions(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java index 04410534c19..3c043b36c7f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java @@ -11,7 +11,11 @@ import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.BulletCollision.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btAlignedObjectArray_btBvhSubtreeInfo extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java index 57b84cbed6b..18822566cf8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java @@ -11,11 +11,7 @@ import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.BulletCollision.*; - //for placement new -// #endif //BT_USE_PLACEMENT_NEW -/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btAlignedObjectArray_btCollisionObjectPointer extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java index 65bb4d380af..01062ad70ae 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java @@ -73,7 +73,7 @@ public class btTriangleIndexVertexArray extends btStridingMeshInterface { * each subpart has a continuous array of vertices and indices */ public native int getNumSubParts(); - public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btCollisionObjectPointer getIndexedMeshArray(); + public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btBvhSubtreeInfo getIndexedMeshArray(); public native void preallocateVertices(int numverts); public native void preallocateIndices(int numindices); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index 4d83f5f82aa..c0646f90bc6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -55,6 +55,9 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #ifdef BT_USE_PLACEMENT_NEW // #include +// Targeting ../BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java + + // Targeting ../BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java @@ -64,9 +67,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // Targeting ../BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java -// Targeting ../BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java - - // #endif //BT_OBJECT_ARRAY__ diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index 22907061826..09395073640 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -62,43 +62,43 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java - - -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java // Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java // Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java + + +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index f7e838e96ff..64dc60cffaa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -728,16 +728,16 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // Targeting ../LinearMath/btAlignedObjectArray_btScalar.java -// Targeting ../LinearMath/btAlignedObjectArray_btVector3.java +// Targeting ../LinearMath/btAlignedObjectArray_btMatrix3x3.java -// Targeting ../LinearMath/btAlignedObjectArray_btVector4.java +// Targeting ../LinearMath/btAlignedObjectArray_btQuaternion.java -// Targeting ../LinearMath/btAlignedObjectArray_btMatrix3x3.java +// Targeting ../LinearMath/btAlignedObjectArray_btVector3.java -// Targeting ../LinearMath/btAlignedObjectArray_btQuaternion.java +// Targeting ../LinearMath/btAlignedObjectArray_btVector4.java diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 47e04e95a05..937cf2ba9f5 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -84,56 +84,64 @@ public class BulletCollision implements InfoMapper { public void map(InfoMap infoMap) { infoMap + .put(new Info("bt32BitAxisSweep3").base("btBroadphaseInterface")) + .put(new Info("btAxisSweep3").base("btBroadphaseInterface")) + + .put(new Info("BT_DECLARE_STACK_ONLY_OBJECT").cppText("#define BT_DECLARE_STACK_ONLY_OBJECT")) .put(new Info("btCollisionObjectData").cppText("#define btCollisionObjectData btCollisionObjectFloatData")) - .put(new Info( "btOverlappingPairCache::getOverlappingPairArray").skip()) - .put(new Info("btHashedOverlappingPairCache::getOverlappingPairArray").skip()) - .put(new Info("btSortedOverlappingPairCache::getOverlappingPairArray").skip()) - .put(new Info("btNullPairCache::getOverlappingPairArray").skip()) - .put(new Info("btCollisionWorld::AllHitsRayResultCallback::m_collisionObjects").skip()) - .put(new Info("PFX_USE_FREE_VECTORMATH").define(false)) - .put(new Info("__SPU__").define(false)) - .put(new Info("btQuantizedBvhData").cppText("#define btQuantizedBvhData btQuantizedBvhFloatData")) .put(new Info("btOptimizedBvhNodeData").cppText("#define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData")) - .put(new Info("btCompoundShapeChild::m_node").skip()) - .put(new Info("btSphereSphereCollisionAlgorithm::getAllContactManifolds").skip()) - .put(new Info("btAxisSweep3").base("btBroadphaseInterface")) - .put(new Info("bt32BitAxisSweep3").base("btBroadphaseInterface")) - .put(new Info("btDbvtBroadphase::m_rayTestStacks").skip()) - .put(new Info("btDbvtProxy").skip()) - .put(new Info("DBVT_BP_PROFILE").define(false)) - .put(new Info("btDispatcher.h").linePatterns("class btRigidBody;").skip()) .put(new Info("btPersistentManifoldData").cppText("#define btPersistentManifoldData btPersistentManifoldFloatData")) - .put(new Info("btPersistentManifold.h").linePatterns("struct btCollisionResult;").skip()) - .put(new Info("DEBUG_PERSISTENCY").define(false)) - .put(new Info("gContactDestroyedCallback").skip()) - .put(new Info("gContactProcessedCallback").skip()) - .put(new Info("gContactStartedCallback").skip()) - .put(new Info("gContactEndedCallback").skip()) - .put(new Info("NO_VIRTUAL_INTERFACE").define(false)) - .put(new Info("btConvexPolyhedron::m_faces").skip()) - .put(new Info("btDbvt::m_stkStack").skip()) - .put(new Info("btDbvt::extractLeaves").skip()) - .put(new Info("btDbvt::rayTestInternal").skip()) - .put(new Info("btDbvt::allocate").skip()) - .put(new Info("DBVT_PREFIX").skip()) - .put(new Info("DBVT_IPOLICY").skip()) + .put(new Info("btQuantizedBvhData").cppText("#define btQuantizedBvhData btQuantizedBvhFloatData")) + .put(new Info("DBVT_INLINE").cppTypes().annotations()) - .put(new Info("DBVT_CHECKTYPE").skip()) - .put(new Info("BT_DECLARE_STACK_ONLY_OBJECT").cppText("#define BT_DECLARE_STACK_ONLY_OBJECT")) + + .put(new Info( + "DBVT_BP_PROFILE", + "DEBUG_PERSISTENCY", + "NO_VIRTUAL_INTERFACE", + "PFX_USE_FREE_VECTORMATH", + "__SPU__" + ).define(false)) + + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btBvhSubtreeInfo")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btCollisionObjectPointer")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btPersistentManifoldPointer")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btQuantizedBvhNode")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btBvhSubtreeInfo")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) + .put(new Info("btDispatcher.h").linePatterns("class btRigidBody;").skip()) + .put(new Info("btPersistentManifold.h").linePatterns("struct btCollisionResult;").skip()) + + .put(new Info( + "DBVT_CHECKTYPE", + "DBVT_IPOLICY", + "DBVT_PREFIX", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btCollisionWorld::AllHitsRayResultCallback::m_collisionObjects", + "btCompoundShapeChild::m_node", + "btConvexPolyhedron::m_faces", + "btDbvt::allocate", + "btDbvt::extractLeaves", + "btDbvt::m_stkStack", + "btDbvt::rayTestInternal", + "btDbvtBroadphase::m_rayTestStacks", + "btDbvtProxy", + "btHashedOverlappingPairCache::getOverlappingPairArray", + "btNullPairCache::getOverlappingPairArray", + "btOverlappingPairCache::getOverlappingPairArray", + "btSortedOverlappingPairCache::getOverlappingPairArray", + "btSphereSphereCollisionAlgorithm::getAllContactManifolds", + "gContactDestroyedCallback", + "gContactEndedCallback", + "gContactProcessedCallback", + "gContactStartedCallback" + ).skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index d23729e4571..104351734f2 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -62,85 +62,74 @@ public class BulletDynamics implements InfoMapper { public void map(InfoMap infoMap) { infoMap - .put(new Info("btRigidBodyData") - .cppText("#define btRigidBodyData btRigidBodyFloatData")) - .put(new Info("defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0") - .define(false)) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btRigidBody")) - .put(new Info("IN_PARALLELL_SOLVER").define(false)) - .put(new Info("BT_BACKWARDS_COMPATIBLE_SERIALIZATION").define(true)) - .put(new Info("btConstraintInfo1").skip()) - .put(new Info("btConstraintInfo2").skip()) - .put(new Info("btPoint2PointConstraintFloatData::m_typeConstraintData").skip()) - .put(new Info("btPoint2PointConstraintDoubleData::m_typeConstraintData").skip()) - .put(new Info("btPoint2PointConstraintDoubleData2::m_typeConstraintData").skip()) - .put(new Info("btPoint2PointConstraintData2") - .cppText("#define btPoint2PointConstraintData2 " + - "btPoint2PointConstraintDoubleData2")) - .put(new Info("btHingeConstraintFloatData::m_typeConstraintData").skip()) - .put(new Info("btHingeConstraintDoubleData::m_typeConstraintData").skip()) - .put(new Info("btHingeConstraintDoubleData2::m_typeConstraintData").skip()) - .put(new Info("btHingeConstraintData") - .cppText("#define btHingeConstraintData " + - "btHingeConstraintFloatData")) - .put(new Info("btConeTwistConstraint::solveConstraintObsolete").skip()) - .put(new Info("btConeTwistConstraintData::m_typeConstraintData").skip()) - .put(new Info("btConeTwistConstraintDoubleData::m_typeConstraintData").skip()) - .put(new Info("btConeTwistConstraintData2") - .cppText("#define btConeTwistConstraintData2 " + - "btConeTwistConstraintData")) - .put(new Info("btGeneric6DofConstraintData::m_typeConstraintData").skip()) - .put(new Info("btGeneric6DofConstraintDoubleData2::m_typeConstraintData").skip()) - .put(new Info("btGeneric6DofConstraintData2") - .cppText("#define btGeneric6DofConstraintData2 " + - "btGeneric6DofConstraintDoubleData2")) - .put(new Info("btSliderConstraintData::m_typeConstraintData").skip()) - .put(new Info("btSliderConstraintDoubleData::m_typeConstraintData").skip()) - .put(new Info("btSliderConstraintData2") - .cppText("#define btSliderConstraintData2 " + - "btSliderConstraintDoubleData2")) - .put(new Info("btGeneric6DofSpringConstraintData2") - .cppText("#define btGeneric6DofSpringConstraintData2 " + - "btGeneric6DofSpringConstraintData")) - .put(new Info("btGeneric6DofSpring2ConstraintData::m_typeConstraintData").skip()) - .put(new Info("btGeneric6DofSpring2ConstraintDoubleData2::" + - "m_typeConstraintData").skip()) - .put(new Info("btGeneric6DofSpring2ConstraintData2") - .cppText("#define btGeneric6DofSpring2ConstraintData2 " + - "btGeneric6DofSpring2ConstraintData")) - .put(new Info("btGearConstraintFloatData::m_typeConstraintData").skip()) - .put(new Info("btGearConstraintDoubleData::m_typeConstraintData").skip()) - .put(new Info("btGearConstraintData") - .cppText("#define btGearConstraintData btGearConstraintFloatData")) - .put(new Info("btSingleConstraintRowSolver").skip()) - .put(new Info("btRaycastVehicle::m_wheelInfo").skip()) - .put(new Info("btMultiBodyData") - .cppText("#define btMultiBodyData btMultiBodyFloatData")) - .put(new Info("btMultiBodyLinkData") - .cppText("#define btMultiBodyLinkData btMultiBodyLinkFloatData")) - .put(new Info("btMultiBodyLinkColliderData") - .cppText("#define btMultiBodyLinkColliderData btMultiBodyLinkColliderFloatData")) - .put(new Info("btMultiBodyConstraint::createConstraintRows").skip()) - .put(new Info("btMultiBodyJacobianData::m_solverBodyPool").skip()) - .put(new Info("btMultiBodyDynamicsWorld::getAnalyticsData").skip()) - .put(new Info("InplaceSolverIslandCallback").skip()) - .put(new Info("MultiBodyInplaceSolverIslandCallback").skip()) - .put(new Info("DeformableBodyInplaceSolverIslandCallback").skip()) - .put(new Info("btSolverInfo").skip()) - .put(new Info("USE_SIMD").define(false)) + .put(new Info("btConeTwistConstraintData2").cppText("#define btConeTwistConstraintData2 btConeTwistConstraintData")) + .put(new Info("btGearConstraintData").cppText("#define btGearConstraintData btGearConstraintFloatData")) + .put(new Info("btGeneric6DofConstraintData2").cppText("#define btGeneric6DofConstraintData2 btGeneric6DofConstraintDoubleData2")) + .put(new Info("btGeneric6DofSpring2ConstraintData2").cppText("#define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData")) + .put(new Info("btGeneric6DofSpringConstraintData2").cppText("#define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData")) + .put(new Info("btHingeConstraintData").cppText("#define btHingeConstraintData btHingeConstraintFloatData")) + .put(new Info("btMultiBodyData").cppText("#define btMultiBodyData btMultiBodyFloatData")) + .put(new Info("btMultiBodyLinkColliderData").cppText("#define btMultiBodyLinkColliderData btMultiBodyLinkColliderFloatData")) + .put(new Info("btMultiBodyLinkData").cppText("#define btMultiBodyLinkData btMultiBodyLinkFloatData")) + .put(new Info("btPoint2PointConstraintData2").cppText("#define btPoint2PointConstraintData2 btPoint2PointConstraintDoubleData2")) + .put(new Info("btRigidBodyData").cppText("#define btRigidBodyData btRigidBodyFloatData")) .put(new Info("btSimdScalar").cppText("#define btSimdScalar btScalar")) + .put(new Info("btSliderConstraintData2").cppText("#define btSliderConstraintData2 btSliderConstraintDoubleData2")) .put(new Info("btTypedConstraintData2").cppText("#define btTypedConstraintData2 btTypedConstraintFloatData")) - .put(new Info("btConstraintArray").skip()) - .put(new Info("btSequentialImpulseConstraintSolverMt::internalConvertMultipleJoints").skip()) - .put(new Info("btBatchedConstraints::m_batches").skip()) - .put(new Info("btBatchedConstraints::m_phases").skip()) - .put(new Info("btSimulationIslandManagerMt::Island::bodyArray").skip()) - .put(new Info("btSimulationIslandManagerMt::Island::manifoldArray").skip()) - .put(new Info("btSimulationIslandManagerMt::Island::constraintArray").skip()) - .put(new Info("btSimulationIslandManagerMt::buildAndProcessIslands").skip()) - .put(new Info("btSimulationIslandManagerMt::serialIslandDispatch").skip()) - .put(new Info("btSimulationIslandManagerMt::parallelIslandDispatch").skip()) - .put(new Info("btSimulationIslandManagerMt::IslandDispatchFunc").skip()) + + .put(new Info( + "IN_PARALLELL_SOLVER", + "USE_SIMD", + "defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0" + ).define(false)) + + .put(new Info( + "BT_BACKWARDS_COMPATIBLE_SERIALIZATION" + ).define(true)) + + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btRigidBody")) + + .put(new Info( + "DeformableBodyInplaceSolverIslandCallback", + "InplaceSolverIslandCallback", + "MultiBodyInplaceSolverIslandCallback", + "btBatchedConstraints::m_batches", + "btBatchedConstraints::m_phases", + "btConeTwistConstraint::solveConstraintObsolete", + "btConeTwistConstraintData::m_typeConstraintData", + "btConeTwistConstraintDoubleData::m_typeConstraintData", + "btConstraintArray", + "btConstraintInfo1", + "btConstraintInfo2", + "btGearConstraintDoubleData::m_typeConstraintData", + "btGearConstraintFloatData::m_typeConstraintData", + "btGeneric6DofConstraintData::m_typeConstraintData", + "btGeneric6DofConstraintDoubleData2::m_typeConstraintData", + "btGeneric6DofSpring2ConstraintData::m_typeConstraintData", + "btGeneric6DofSpring2ConstraintDoubleData2::m_typeConstraintData", + "btHingeConstraintDoubleData2::m_typeConstraintData", + "btHingeConstraintDoubleData::m_typeConstraintData", + "btHingeConstraintFloatData::m_typeConstraintData", + "btMultiBodyConstraint::createConstraintRows", + "btMultiBodyDynamicsWorld::getAnalyticsData", + "btMultiBodyJacobianData::m_solverBodyPool", + "btPoint2PointConstraintDoubleData2::m_typeConstraintData", + "btPoint2PointConstraintDoubleData::m_typeConstraintData", + "btPoint2PointConstraintFloatData::m_typeConstraintData", + "btRaycastVehicle::m_wheelInfo", + "btSequentialImpulseConstraintSolverMt::internalConvertMultipleJoints", + "btSimulationIslandManagerMt::Island::bodyArray", + "btSimulationIslandManagerMt::Island::constraintArray", + "btSimulationIslandManagerMt::Island::manifoldArray", + "btSimulationIslandManagerMt::IslandDispatchFunc", + "btSimulationIslandManagerMt::buildAndProcessIslands", + "btSimulationIslandManagerMt::parallelIslandDispatch", + "btSimulationIslandManagerMt::serialIslandDispatch", + "btSingleConstraintRowSolver", + "btSliderConstraintData::m_typeConstraintData", + "btSliderConstraintDoubleData::m_typeConstraintData", + "btSolverInfo" + ).skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index a7d2d6981e0..495aa48086b 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -42,155 +42,131 @@ public class BulletSoftBody implements InfoMapper { public void map(InfoMap infoMap) { infoMap - .put(new Info("btSparseSdf<3>").pointerTypes("btSparseSdf_3")) - .put(new Info("btSparseSdf<3>::IntFrac").skip()) - .put(new Info("btSparseSdf<3>::Cell").skip()) - .put(new Info("btSparseSdf<3>::cells").skip()) - .put(new Info("btSoftBody::m_collisionDisabledObjects").skip()) - .put(new Info("btSoftBody::Cluster::m_nodes").skip()) - .put(new Info("btSoftBody::Cluster::m_leaf").skip()) - .put(new Info("btSoftBody::m_tetraScratches").skip()) - .put(new Info("btSoftBody::m_tetraScratchesTn").skip()) - .put(new Info("btSoftBody::m_deformableAnchors").skip()) - .put(new Info("btSoftBody::m_nodeRigidContacts").skip()) - .put(new Info("btSoftBody::m_faceRigidContacts").skip()) - .put(new Info("btSoftBody::m_faceNodeContacts").skip()) - .put(new Info("btSoftBody::m_renderNodesParents").skip()) - .put(new Info("btSoftBody::solveClusters").skip()) - .put(new Info("btSoftBody::m_fdbvnt").skip()) - .put(new Info("btSoftBody::updateNode").skip()) - .put(new Info("btSoftBody::Joint::eType").skip()) - .put(new Info("btSoftBody::Joint::eType::_").skip()) - .put(new Info("btSoftBody::Face::m_leaf").skip()) - .put(new Info("btSoftBody::Node::m_leaf").skip()) - .put(new Info("btSoftBody::Tetra::m_leaf").skip()) - .put(new Info("btSoftBody::AJoint::Type").skip()) - .put(new Info("btSoftBody::LJoint::Type").skip()) - .put(new Info("btSoftBody::CJoint::Type").skip()) - .put(new Info("btSoftBody::RayFromToCaster").skip()) .put(new Info("btSoftBodyData").cppText("#define btSoftBodyData btSoftBodyFloatData")) - .put(new Info("SAFE_EPSILON").skip()) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody")) - .put(new Info("btSoftBodySolver::SolverTypes").enumerate()) - .put(new Info( - "btDeformableBodySolver::computeStep", - "btDeformableBodySolver::computeDescentStep" - ).skip()) - .put(new Info("btDeformableMultiBodyDynamicsWorld::setSolverCallback").skip()) - .put(new Info("btDeformableMultiBodyDynamicsWorld::rayTestSingle").skip()) - .put(new Info("btDeformableMultiBodyDynamicsWorld::solveMultiBodyConstraints").skip()) - .put(new Info("btCPUVertexBufferDescriptor::getBufferType").skip()) - .put(new Info("btSoftBodyVertexData").skip()) - .put(new Info("btSoftBodyTriangleData").skip()) - .put(new Info("btSoftBodyLinkData").skip()) - .put(new Info("btDeformableBackwardEulerObjective::m_lf").skip()) - .put(new Info("btDeformableBackwardEulerObjective::m_nodes").skip()) - .put(new Info("btDeformableBackwardEulerObjective::getIndices").skip()) - .put(new Info("btDeformableBackwardEulerObjective::m_preconditioner").skip()) - .put(new Info("btDeformableBackwardEulerObjective::m_massPreconditioner").skip()) - .put(new Info("btDeformableBackwardEulerObjective::m_KKTPreconditioner").skip()) - .put(new Info("btDeformableBackwardEulerObjective::m_projection").skip()) - .put(new Info("btDeformableBackwardEulerObjective::computeStep").skip()) - .put(new Info("btDeformableLagrangianForce::m_nodes").skip()) - .put(new Info("btDeformableLagrangianForce::setIndices").skip()) - - // typedef btAlignedObjectArray tFaceArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Face")) - .put(new Info("btSoftBody::Face").pointerTypes("btSoftBody.Face")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - // typedef btAlignedObjectArray tNoteArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Note")) - .put(new Info("btSoftBody::Note").pointerTypes("btSoftBody.Note")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - - // typedef btAlignedObjectArray tNodeArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Node")) - .put(new Info("btSoftBody::Node").pointerTypes("btSoftBody.Node")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - - // typedef btAlignedObjectArray tRenderNodeArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RenderNode")) - .put(new Info("btSoftBody::RenderNode").pointerTypes("btSoftBody.RenderNode")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) + .put(new Info("btSoftBodySolver::SolverTypes").enumerate()) - // typedef btAlignedObjectArray tClusterArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Anchor")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_ClusterPointer")) - .put(new Info("btSoftBody::Cluster").pointerTypes("btSoftBody.Cluster")) - - // typedef btAlignedObjectArray tLinkArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Face")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_JointPointer")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Link")) - .put(new Info("btSoftBody::Link").pointerTypes("btSoftBody.Link")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - - // typedef btAlignedObjectArray tRenderFaceArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_MaterialPointer")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Node")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Note")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RContact")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RenderFace")) - .put(new Info("btSoftBody::RenderFace").pointerTypes("btSoftBody.RenderFace")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - - // typedef btAlignedObjectArray tTetraArray; + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RenderNode")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_SContact")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Tetra")) - .put(new Info("btSoftBody::Tetra").pointerTypes("btSoftBody.Tetra")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - - // typedef btAlignedObjectArray tAnchorArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Anchor")) .put(new Info("btSoftBody::Anchor").pointerTypes("btSoftBody.Anchor")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - - // typedef btAlignedObjectArray tRContactArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RContact")) + .put(new Info("btSoftBody::Cluster").pointerTypes("btSoftBody.Cluster")) + .put(new Info("btSoftBody::Face").pointerTypes("btSoftBody.Face")) + .put(new Info("btSoftBody::Joint").pointerTypes("btSoftBody.Joint")) + .put(new Info("btSoftBody::Link").pointerTypes("btSoftBody.Link")) + .put(new Info("btSoftBody::Material").pointerTypes("btSoftBody.Material")) + .put(new Info("btSoftBody::Node").pointerTypes("btSoftBody.Node")) + .put(new Info("btSoftBody::Note").pointerTypes("btSoftBody.Note")) .put(new Info("btSoftBody::RContact").pointerTypes("btSoftBody.RContact")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - - // typedef btAlignedObjectArray tSContactArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_SContact")) + .put(new Info("btSoftBody::RenderFace").pointerTypes("btSoftBody.RenderFace")) + .put(new Info("btSoftBody::RenderNode").pointerTypes("btSoftBody.RenderNode")) .put(new Info("btSoftBody::SContact").pointerTypes("btSoftBody.SContact")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch").skip()) - .put(new Info("btAlignedObjectArray::findLinearSearch2").skip()) - .put(new Info("btAlignedObjectArray::remove").skip()) - - // typedef btAlignedObjectArray tMaterialArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_MaterialPointer")) - .put(new Info("btSoftBody::Material").pointerTypes("btSoftBody.Material")) - - // typedef btAlignedObjectArray tJointArray; - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_JointPointer")) - .put(new Info("btSoftBody::Joint").pointerTypes("btSoftBody.Joint")) + .put(new Info("btSoftBody::Tetra").pointerTypes("btSoftBody.Tetra")) + .put(new Info("btSparseSdf<3>").pointerTypes("btSparseSdf_3")) - .put(new Info("btSoftBody::eVSolver").skip()) - .put(new Info("btSoftBody::ePSolver").skip()) - .put(new Info("btSoftBody::getSolver").skip()) - .put(new Info("btSoftBody::fMaterial").skip()) - .put(new Info("btSoftBody::fCollision").skip()) + .put(new Info( + "SAFE_EPSILON", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btCPUVertexBufferDescriptor::getBufferType", + "btDeformableBackwardEulerObjective::computeStep", + "btDeformableBackwardEulerObjective::getIndices", + "btDeformableBackwardEulerObjective::m_KKTPreconditioner", + "btDeformableBackwardEulerObjective::m_lf", + "btDeformableBackwardEulerObjective::m_massPreconditioner", + "btDeformableBackwardEulerObjective::m_nodes", + "btDeformableBackwardEulerObjective::m_preconditioner", + "btDeformableBackwardEulerObjective::m_projection", + "btDeformableBodySolver::computeDescentStep", + "btDeformableBodySolver::computeStep", + "btDeformableLagrangianForce::m_nodes", + "btDeformableLagrangianForce::setIndices", + "btDeformableMultiBodyDynamicsWorld::rayTestSingle", + "btDeformableMultiBodyDynamicsWorld::setSolverCallback", + "btDeformableMultiBodyDynamicsWorld::solveMultiBodyConstraints", + "btSoftBody::AJoint::Type", + "btSoftBody::CJoint::Type", + "btSoftBody::Cluster::m_leaf", + "btSoftBody::Cluster::m_nodes", + "btSoftBody::Face::m_leaf", + "btSoftBody::Joint::eType", + "btSoftBody::Joint::eType::_", + "btSoftBody::LJoint::Type", + "btSoftBody::Node::m_leaf", + "btSoftBody::RayFromToCaster", + "btSoftBody::Tetra::m_leaf", + "btSoftBody::ePSolver", + "btSoftBody::eVSolver", + "btSoftBody::fCollision", + "btSoftBody::fMaterial", + "btSoftBody::getSolver", + "btSoftBody::m_collisionDisabledObjects", + "btSoftBody::m_deformableAnchors", + "btSoftBody::m_faceNodeContacts", + "btSoftBody::m_faceRigidContacts", + "btSoftBody::m_fdbvnt", + "btSoftBody::m_nodeRigidContacts", + "btSoftBody::m_renderNodesParents", + "btSoftBody::m_tetraScratches", + "btSoftBody::m_tetraScratchesTn", + "btSoftBody::solveClusters", + "btSoftBody::updateNode", + "btSoftBodyLinkData", + "btSoftBodyTriangleData", + "btSoftBodyVertexData", + "btSparseSdf<3>::Cell", + "btSparseSdf<3>::IntFrac", + "btSparseSdf<3>::cells" + ).skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 8a2cab7aa47..4fd359c0a76 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -41,61 +41,58 @@ public class LinearMath implements InfoMapper { public void map(InfoMap infoMap) { infoMap - // btScalar.h - .put(new Info("_WIN32").define(false)) - .put(new Info("defined(_MSC_VER)").define(false)) - .put(new Info("defined\t(__CELLOS_LV2__)").define(false)) - .put(new Info("USE_LIBSPE2").define(false)) - .put(new Info("(defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION)))").define(false)) - .put(new Info("defined(DEBUG) || defined (_DEBUG)").define(false)) - .put(new Info("defined(BT_USE_SSE) || defined(BT_USE_NEON)").define(false)) - .put(new Info("BT_USE_NEON").define(false)) - .put(new Info("defined(__SPU__) && defined(__CELLOS_LV2__)").define(false)) - .put(new Info("SIMD_FORCE_INLINE").cppTypes().annotations()) - .put(new Info("BT_INFINITY").skip()) - .put(new Info("BT_NAN").skip()) - .put(new Info("BT_USE_DOUBLE_PRECISION").define(false)) - .put(new Info("defined(BT_USE_DOUBLE_PRECISION)").define(false)) - .put(new Info("SIMD_EPSILON").skip()) - .put(new Info("SIMD_INFINITY").skip()) .put(new Info("ATTRIBUTE_ALIGNED16").cppText("#define ATTRIBUTE_ALIGNED16(x) x")) - .put(new Info("btInfMaskConverter").skip()) - - // btVector3.h - .put(new Info("BT_DECLARE_ALIGNED_ALLOCATOR").skip()) - .put(new Info("(defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)").define(false)) - .put(new Info("btVector3Data").cppText("#define btVector3Data btVector3FloatData")) - .put(new Info("defined BT_USE_SSE").define(false)) - - // btQuaternion.h - .put(new Info("BT_USE_SSE").define(false)) - .put(new Info("defined(BT_USE_SSE)").define(false)) - .put(new Info("defined(BT_USE_NEON)").define(false)) + .put(new Info("btMatrix3x3Data").cppText("#define btMatrix3x3Data btMatrix3x3FloatData")) .put(new Info("btQuaternionData").cppText("#define btQuaternionData btQuaternionFloatData")) + .put(new Info("btTransformData").cppText("#define btTransformData btTransformFloatData")) + .put(new Info("btVector3Data").cppText("#define btVector3Data btVector3FloatData")) - // btMatrix3x3.h - .put(new Info("btMatrix3x3Data").cppText("#define btMatrix3x3Data btMatrix3x3FloatData")) + .put(new Info("SIMD_FORCE_INLINE").cppTypes().annotations()) - // btTransform.h - .put(new Info("btTransformData").cppText("#define btTransformData btTransformFloatData")) + .put(new Info( + "(defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION)))", + "(defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)", + "BT_USE_DOUBLE_PRECISION", + "BT_USE_NEON", + "BT_USE_SSE", + "ENABLE_INMEMORY_SERIALIZER", + "USE_LIBSPE2", + "_WIN32", + "defined BT_USE_SSE", + "defined(BT_USE_DOUBLE_PRECISION)", + "defined(BT_USE_NEON)", + "defined(BT_USE_SSE) || defined(BT_USE_NEON)", + "defined(BT_USE_SSE)", + "defined(DEBUG) || defined (_DEBUG)", + "defined(_MSC_VER)", + "defined(__SPU__) && defined(__CELLOS_LV2__)", + "defined\t(__CELLOS_LV2__)" + ).define(false)) - // btSerializer.h - .put(new Info("btBulletSerializedArrays").skip()) - .put(new Info("btHashMap").pointerTypes("btHashMap_btHashPtr_voidPointer")) .put(new Info("btDefaultSerializer").immutable(true)) - .put(new Info("ENABLE_INMEMORY_SERIALIZER").define(false)) - // btAlignedObjectArray.h - .put(new Info("btAlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_bool")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_char")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_int")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btScalar")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector3")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector4")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btMatrix3x3")) - .put(new Info("btAlignedObjectArray::findBinarySearch").skip()) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btQuaternion")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector3")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector4")) + .put(new Info("btHashMap").pointerTypes("btHashMap_btHashPtr_voidPointer")) + + .put(new Info("btAlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) + + .put(new Info( + "BT_DECLARE_ALIGNED_ALLOCATOR", + "BT_INFINITY", + "BT_NAN", + "SIMD_EPSILON", + "SIMD_INFINITY", + "btAlignedObjectArray::findBinarySearch", + "btBulletSerializedArrays", + "btInfMaskConverter" + ).skip()) ; } } From fe4c0c53201798db9d6ac89e6f51c793763bf09a Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 23 Feb 2022 14:37:45 +0800 Subject: [PATCH 32/81] Missing mapping for btAlignedObjectArray --- .../btAlignedObjectArray_btIndexedMesh.java | 88 +++++++++++++++++++ .../btTriangleIndexVertexArray.java | 2 +- .../bullet/global/BulletCollision.java | 3 + .../bullet/presets/BulletCollision.java | 5 ++ 4 files changed, 97 insertions(+), 1 deletion(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btIndexedMesh.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btIndexedMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btIndexedMesh.java new file mode 100644 index 00000000000..97325ce5881 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btIndexedMesh.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btAlignedObjectArray_btIndexedMesh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedObjectArray_btIndexedMesh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedObjectArray_btIndexedMesh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedObjectArray_btIndexedMesh position(long position) { + return (btAlignedObjectArray_btIndexedMesh)super.position(position); + } + @Override public btAlignedObjectArray_btIndexedMesh getPointer(long i) { + return new btAlignedObjectArray_btIndexedMesh((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btAlignedObjectArray_btIndexedMesh put(@Const @ByRef btAlignedObjectArray_btIndexedMesh other); + public btAlignedObjectArray_btIndexedMesh() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btAlignedObjectArray_btIndexedMesh(@Const @ByRef btAlignedObjectArray_btIndexedMesh otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btIndexedMesh otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btIndexedMesh at(int n); + + public native @ByRef @Name("operator []") btIndexedMesh get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btIndexedMesh()") btIndexedMesh fillData); + public native void resize(int newsize); + public native @ByRef btIndexedMesh expandNonInitializing(); + + public native @ByRef btIndexedMesh expand(@Const @ByRef(nullValue = "btIndexedMesh()") btIndexedMesh fillValue); + public native @ByRef btIndexedMesh expand(); + + public native void push_back(@Const @ByRef btIndexedMesh _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btIndexedMesh otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java index 01062ad70ae..871bae11ccf 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java @@ -73,7 +73,7 @@ public class btTriangleIndexVertexArray extends btStridingMeshInterface { * each subpart has a continuous array of vertices and indices */ public native int getNumSubParts(); - public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btBvhSubtreeInfo getIndexedMeshArray(); + public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btIndexedMesh getIndexedMeshArray(); public native void preallocateVertices(int numverts); public native void preallocateIndices(int numindices); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index c0646f90bc6..29f37905982 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -61,6 +61,9 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // Targeting ../BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java +// Targeting ../BulletCollision/btAlignedObjectArray_btIndexedMesh.java + + // Targeting ../BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 937cf2ba9f5..5836813dff2 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -105,6 +105,7 @@ public void map(InfoMap infoMap) { .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btBvhSubtreeInfo")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btCollisionObjectPointer")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btIndexedMesh")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btPersistentManifoldPointer")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btQuantizedBvhNode")) @@ -119,6 +120,10 @@ public void map(InfoMap infoMap) { "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", From b5b768fab2385c0f75c35fc12ae8aa81b34f7a80 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 23 Feb 2022 14:53:18 +0800 Subject: [PATCH 33/81] Rename btAlignedObjectArray_btRigidBody and btAlignedObjectArray_btSoftBody Follow naming convention of template instances. --- ...lignedObjectArray_btRigidBodyPointer.java} | 24 +++++++++---------- .../btDiscreteDynamicsWorld.java | 2 +- ...AlignedObjectArray_btSoftBodyPointer.java} | 24 +++++++++---------- .../btDeformableBackwardEulerObjective.java | 6 ++--- .../btDeformableBodySolver.java | 6 ++--- .../btDeformableLagrangianForce.java | 2 +- .../btDeformableMultiBodyDynamicsWorld.java | 2 +- .../bullet/BulletSoftBody/btSoftBody.java | 6 ++--- .../BulletSoftBody/btSoftBodySolver.java | 4 ++-- .../btSoftMultiBodyDynamicsWorld.java | 2 +- .../btSoftRigidDynamicsWorld.java | 2 +- .../bullet/global/BulletDynamics.java | 2 +- .../bullet/global/BulletSoftBody.java | 2 +- .../bullet/presets/BulletDynamics.java | 2 +- .../bullet/presets/BulletSoftBody.java | 2 +- 15 files changed, 44 insertions(+), 44 deletions(-) rename bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/{btAlignedObjectArray_btRigidBody.java => btAlignedObjectArray_btRigidBodyPointer.java} (78%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody.java => btAlignedObjectArray_btSoftBodyPointer.java} (79%) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java similarity index 78% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java index 42d4b762c88..cd7618c00de 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java @@ -19,27 +19,27 @@ /**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btAlignedObjectArray_btRigidBody extends Pointer { +public class btAlignedObjectArray_btRigidBodyPointer extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btRigidBody(Pointer p) { super(p); } + public btAlignedObjectArray_btRigidBodyPointer(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btRigidBody(long size) { super((Pointer)null); allocateArray(size); } + public btAlignedObjectArray_btRigidBodyPointer(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btRigidBody position(long position) { - return (btAlignedObjectArray_btRigidBody)super.position(position); + @Override public btAlignedObjectArray_btRigidBodyPointer position(long position) { + return (btAlignedObjectArray_btRigidBodyPointer)super.position(position); } - @Override public btAlignedObjectArray_btRigidBody getPointer(long i) { - return new btAlignedObjectArray_btRigidBody((Pointer)this).offsetAddress(i); + @Override public btAlignedObjectArray_btRigidBodyPointer getPointer(long i) { + return new btAlignedObjectArray_btRigidBodyPointer((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btRigidBody put(@Const @ByRef btAlignedObjectArray_btRigidBody other); - public btAlignedObjectArray_btRigidBody() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btAlignedObjectArray_btRigidBodyPointer put(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer other); + public btAlignedObjectArray_btRigidBodyPointer() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btRigidBody(@Const @ByRef btAlignedObjectArray_btRigidBody otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btRigidBody otherArray); + public btAlignedObjectArray_btRigidBodyPointer(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); /** return the number of elements in the array */ public native int size(); @@ -90,5 +90,5 @@ public class btAlignedObjectArray_btRigidBody extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btRigidBody otherArray); + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java index 9786457d5d3..fdba271f3a3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java @@ -117,5 +117,5 @@ public class btDiscreteDynamicsWorld extends btDynamicsWorld { public native void setLatencyMotionStateInterpolation(@Cast("bool") boolean latencyInterpolation); public native @Cast("bool") boolean getLatencyMotionStateInterpolation(); - public native @ByRef btAlignedObjectArray_btRigidBody getNonStaticRigidBodies(); + public native @ByRef btAlignedObjectArray_btRigidBodyPointer getNonStaticRigidBodies(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBodyPointer.java similarity index 79% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBodyPointer.java index 7dc93bc43a1..c208e1a0bd8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBodyPointer.java @@ -21,27 +21,27 @@ /**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody extends Pointer { +public class btAlignedObjectArray_btSoftBodyPointer extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody(Pointer p) { super(p); } + public btAlignedObjectArray_btSoftBodyPointer(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody(long size) { super((Pointer)null); allocateArray(size); } + public btAlignedObjectArray_btSoftBodyPointer(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody position(long position) { - return (btAlignedObjectArray_btSoftBody)super.position(position); + @Override public btAlignedObjectArray_btSoftBodyPointer position(long position) { + return (btAlignedObjectArray_btSoftBodyPointer)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody getPointer(long i) { - return new btAlignedObjectArray_btSoftBody((Pointer)this).offsetAddress(i); + @Override public btAlignedObjectArray_btSoftBodyPointer getPointer(long i) { + return new btAlignedObjectArray_btSoftBodyPointer((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody put(@Const @ByRef btAlignedObjectArray_btSoftBody other); - public btAlignedObjectArray_btSoftBody() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBodyPointer put(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer other); + public btAlignedObjectArray_btSoftBodyPointer() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody(@Const @ByRef btAlignedObjectArray_btSoftBody otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody otherArray); + public btAlignedObjectArray_btSoftBodyPointer(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer otherArray); /** return the number of elements in the array */ public native int size(); @@ -92,5 +92,5 @@ public class btAlignedObjectArray_btSoftBody extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody otherArray); + public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java index 2465d0f18cf..83c23c0b568 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java @@ -25,7 +25,7 @@ public class btDeformableBackwardEulerObjective extends Pointer { public native @Cast("btScalar") float m_dt(); public native btDeformableBackwardEulerObjective m_dt(float setter); - public native @ByRef btAlignedObjectArray_btSoftBody m_softBodies(); public native btDeformableBackwardEulerObjective m_softBodies(btAlignedObjectArray_btSoftBody setter); + public native @ByRef btAlignedObjectArray_btSoftBodyPointer m_softBodies(); public native btDeformableBackwardEulerObjective m_softBodies(btAlignedObjectArray_btSoftBodyPointer setter); @MemberGetter public native @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 m_backupVelocity(); @@ -34,8 +34,8 @@ public class btDeformableBackwardEulerObjective extends Pointer { - public btDeformableBackwardEulerObjective(@ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 backup_v) { super((Pointer)null); allocate(softBodies, backup_v); } - private native void allocate(@ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 backup_v); + public btDeformableBackwardEulerObjective(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 backup_v) { super((Pointer)null); allocate(softBodies, backup_v); } + private native void allocate(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 backup_v); public native void initialize(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java index 6a1fa51feb0..f7bfca41c01 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java @@ -51,7 +51,7 @@ public class btDeformableBodySolver extends btSoftBodySolver { public native void solveDeformableConstraints(@Cast("btScalar") float solverdt); // resize/clear data structures - public native void reinitialize(@Const @ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("btScalar") float dt); + public native void reinitialize(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("btScalar") float dt); // set up contact constraints public native void setConstraints(@Const @ByRef btContactSolverInfo infoGlobal); @@ -128,8 +128,8 @@ public class btDeformableBodySolver extends btSoftBodySolver { public native @Cast("btScalar") float kineticEnergy(); // unused functions - public native void optimize(@ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("bool") boolean forceUpdate/*=false*/); - public native void optimize(@ByRef btAlignedObjectArray_btSoftBody softBodies); + public native void optimize(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("bool") boolean forceUpdate/*=false*/); + public native void optimize(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies); public native void solveConstraints(@Cast("btScalar") float dt); public native @Cast("bool") boolean checkInitialized(); public native void copyBackToSoftBodies(@Cast("bool") boolean bMove/*=true*/); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java index f5dfdc12f96..e3ee2dcb600 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java @@ -23,7 +23,7 @@ public class btDeformableLagrangianForce extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btDeformableLagrangianForce(Pointer p) { super(p); } - public native @ByRef btAlignedObjectArray_btSoftBody m_softBodies(); public native btDeformableLagrangianForce m_softBodies(btAlignedObjectArray_btSoftBody setter); + public native @ByRef btAlignedObjectArray_btSoftBodyPointer m_softBodies(); public native btDeformableLagrangianForce m_softBodies(btAlignedObjectArray_btSoftBodyPointer setter); // add all forces diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java index 30a0c6e8553..8bdbcb9da43 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java @@ -44,7 +44,7 @@ public class btDeformableMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld public native void addSoftBody(btSoftBody body, int collisionFilterGroup/*=btBroadphaseProxy::DefaultFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter*/); public native void addSoftBody(btSoftBody body); - public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBody getSoftBodyArray(); + public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBodyPointer getSoftBodyArray(); public native @ByRef btSoftBodyWorldInfo getWorldInfo(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java index 6d004ae06cd..51c3a8bd71c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java @@ -1071,9 +1071,9 @@ public static class Config extends Pointer { public native int diterations(); public native Config diterations(int setter); // Drift solver iterations public native int citerations(); public native Config citerations(int setter); // Cluster solver iterations public native int collisions(); public native Config collisions(int setter); // Collisions flags - public native @ByRef @Cast("btSoftBody::tVSolverArray*") btAlignedObjectArray_btSoftBody m_vsequence(); public native Config m_vsequence(btAlignedObjectArray_btSoftBody setter); // Velocity solvers sequence - public native @ByRef @Cast("btSoftBody::tPSolverArray*") btAlignedObjectArray_btSoftBody m_psequence(); public native Config m_psequence(btAlignedObjectArray_btSoftBody setter); // Position solvers sequence - public native @ByRef @Cast("btSoftBody::tPSolverArray*") btAlignedObjectArray_btSoftBody m_dsequence(); public native Config m_dsequence(btAlignedObjectArray_btSoftBody setter); // Drift solvers sequence + public native @ByRef @Cast("btSoftBody::tVSolverArray*") btAlignedObjectArray_btSoftBodyPointer m_vsequence(); public native Config m_vsequence(btAlignedObjectArray_btSoftBodyPointer setter); // Velocity solvers sequence + public native @ByRef @Cast("btSoftBody::tPSolverArray*") btAlignedObjectArray_btSoftBodyPointer m_psequence(); public native Config m_psequence(btAlignedObjectArray_btSoftBodyPointer setter); // Position solvers sequence + public native @ByRef @Cast("btSoftBody::tPSolverArray*") btAlignedObjectArray_btSoftBodyPointer m_dsequence(); public native Config m_dsequence(btAlignedObjectArray_btSoftBodyPointer setter); // Drift solvers sequence public native @Cast("btScalar") float drag(); public native Config drag(float setter); // deformable air drag public native @Cast("btScalar") float m_maxStress(); public native Config m_maxStress(float setter); // Maximum principle first Piola stress } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java index ca16e90eb13..fe207207cc4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java @@ -48,8 +48,8 @@ public enum SolverTypes { public native @Cast("bool") boolean checkInitialized(); /** Optimize soft bodies in this solver. */ - public native void optimize(@ByRef btAlignedObjectArray_btSoftBody softBodies, @Cast("bool") boolean forceUpdate/*=false*/); - public native void optimize(@ByRef btAlignedObjectArray_btSoftBody softBodies); + public native void optimize(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("bool") boolean forceUpdate/*=false*/); + public native void optimize(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies); /** Copy necessary data back to the original soft body source objects. */ public native void copyBackToSoftBodies(@Cast("bool") boolean bMove/*=true*/); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java index c349396ca69..282c9fd8f2e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java @@ -46,7 +46,7 @@ public class btSoftMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld { public native @Cast("btDynamicsWorldType") int getWorldType(); - public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBody getSoftBodyArray(); + public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBodyPointer getSoftBodyArray(); public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java index 0284a379fff..22dd64da0dd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java @@ -45,7 +45,7 @@ public class btSoftRigidDynamicsWorld extends btDiscreteDynamicsWorld { public native @Cast("btDynamicsWorldType") int getWorldType(); - public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBody getSoftBodyArray(); + public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBodyPointer getSoftBodyArray(); public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index 16183f1190e..68c941e999f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -57,7 +57,7 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../BulletDynamics/btAlignedObjectArray_btRigidBody.java +// Targeting ../BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index 09395073640..764879ac791 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -59,7 +59,7 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody.java +// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBodyPointer.java // Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index 104351734f2..01b24399cbf 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -87,7 +87,7 @@ public void map(InfoMap infoMap) { "BT_BACKWARDS_COMPATIBLE_SERIALIZATION" ).define(true)) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btRigidBody")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btRigidBodyPointer")) .put(new Info( "DeformableBodyInplaceSolverIslandCallback", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 495aa48086b..619c9696536 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -46,7 +46,7 @@ public void map(InfoMap infoMap) { .put(new Info("btSoftBodySolver::SolverTypes").enumerate()) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody")) + .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBodyPointer")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Anchor")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_ClusterPointer")) .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Face")) From 43da83b7d44e8721713131e526a1fda4c35c89cb Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 23 Feb 2022 15:01:12 +0800 Subject: [PATCH 34/81] Skip tVSolverArray and tPSolverArray Not used by bullet's examples. --- .../java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java | 5 +---- .../java/org/bytedeco/bullet/presets/BulletSoftBody.java | 2 ++ 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java index 51c3a8bd71c..248ce89ce15 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java @@ -1070,10 +1070,7 @@ public static class Config extends Pointer { public native int piterations(); public native Config piterations(int setter); // Positions solver iterations public native int diterations(); public native Config diterations(int setter); // Drift solver iterations public native int citerations(); public native Config citerations(int setter); // Cluster solver iterations - public native int collisions(); public native Config collisions(int setter); // Collisions flags - public native @ByRef @Cast("btSoftBody::tVSolverArray*") btAlignedObjectArray_btSoftBodyPointer m_vsequence(); public native Config m_vsequence(btAlignedObjectArray_btSoftBodyPointer setter); // Velocity solvers sequence - public native @ByRef @Cast("btSoftBody::tPSolverArray*") btAlignedObjectArray_btSoftBodyPointer m_psequence(); public native Config m_psequence(btAlignedObjectArray_btSoftBodyPointer setter); // Position solvers sequence - public native @ByRef @Cast("btSoftBody::tPSolverArray*") btAlignedObjectArray_btSoftBodyPointer m_dsequence(); public native Config m_dsequence(btAlignedObjectArray_btSoftBodyPointer setter); // Drift solvers sequence + public native int collisions(); public native Config collisions(int setter); // Collisions flags // Velocity solvers sequence // Position solvers sequence // Drift solvers sequence public native @Cast("btScalar") float drag(); public native Config drag(float setter); // deformable air drag public native @Cast("btScalar") float m_maxStress(); public native Config m_maxStress(float setter); // Maximum principle first Piola stress } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 619c9696536..c5e6e4f07df 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -159,6 +159,8 @@ public void map(InfoMap infoMap) { "btSoftBody::m_tetraScratches", "btSoftBody::m_tetraScratchesTn", "btSoftBody::solveClusters", + "btSoftBody::tPSolverArray", + "btSoftBody::tVSolverArray", "btSoftBody::updateNode", "btSoftBodyLinkData", "btSoftBodyTriangleData", From da87cef941a4d5624cdf2da2ed5f01ec4795b68e Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 24 Feb 2022 11:51:58 +0800 Subject: [PATCH 35/81] Simplify mappings for btAlignedObjectArray instances --- .../bullet/presets/BulletCollision.java | 10 +++---- .../bullet/presets/BulletDynamics.java | 2 +- .../bullet/presets/BulletSoftBody.java | 28 +++++++++---------- .../bytedeco/bullet/presets/LinearMath.java | 16 +++++------ 4 files changed, 28 insertions(+), 28 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 5836813dff2..80d05a3b667 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -103,11 +103,11 @@ public void map(InfoMap infoMap) { "__SPU__" ).define(false)) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btBvhSubtreeInfo")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btCollisionObjectPointer")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btIndexedMesh")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btPersistentManifoldPointer")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btQuantizedBvhNode")) + .put(new Info("btAlignedObjectArray").pointerTypes("btBvhSubtreeInfoArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btCollisionObjectArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btIndexedMeshArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btPersistentManifoldArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btQuantizedBvhNodeArray")) .put(new Info("btDispatcher.h").linePatterns("class btRigidBody;").skip()) .put(new Info("btPersistentManifold.h").linePatterns("struct btCollisionResult;").skip()) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index 01b24399cbf..cfae84186e5 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -87,7 +87,7 @@ public void map(InfoMap infoMap) { "BT_BACKWARDS_COMPATIBLE_SERIALIZATION" ).define(true)) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btRigidBodyPointer")) + .put(new Info("btAlignedObjectArray").pointerTypes("btRigidBodyArray")) .put(new Info( "DeformableBodyInplaceSolverIslandCallback", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index c5e6e4f07df..e17397b3f56 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -46,20 +46,20 @@ public void map(InfoMap infoMap) { .put(new Info("btSoftBodySolver::SolverTypes").enumerate()) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBodyPointer")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Anchor")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_ClusterPointer")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Face")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_JointPointer")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Link")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_MaterialPointer")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Node")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Note")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RContact")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RenderFace")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_RenderNode")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_SContact")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btSoftBody_Tetra")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyAnchorArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyClusterArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyFaceArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyJointArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyLinkArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyMaterialArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyNodeArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyNoteArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyRContactArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyRenderFaceArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyRenderNodeArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodySContactArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyTetraArray")) .put(new Info("btSoftBody::Anchor").pointerTypes("btSoftBody.Anchor")) .put(new Info("btSoftBody::Cluster").pointerTypes("btSoftBody.Cluster")) .put(new Info("btSoftBody::Face").pointerTypes("btSoftBody.Face")) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 4fd359c0a76..71dc62eacf2 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -71,14 +71,14 @@ public void map(InfoMap infoMap) { .put(new Info("btDefaultSerializer").immutable(true)) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_bool")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_char")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_int")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btScalar")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btMatrix3x3")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btQuaternion")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector3")) - .put(new Info("btAlignedObjectArray").pointerTypes("btAlignedObjectArray_btVector4")) + .put(new Info("btAlignedObjectArray").pointerTypes("btBoolArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btCharArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btIntArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btScalarArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btMatrix3x3Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("btQuaternionArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btVector3Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("btVector4Array")) .put(new Info("btHashMap").pointerTypes("btHashMap_btHashPtr_voidPointer")) .put(new Info("btAlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) From a3b7c08b68f483a211724ec1ba5dac8a0bcf647d Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 24 Feb 2022 11:54:53 +0800 Subject: [PATCH 36/81] Update bullet's generated bindings --- ...eeInfo.java => btBvhSubtreeInfoArray.java} | 24 ++++---- .../BulletCollision/btCollisionAlgorithm.java | 2 +- ...inter.java => btCollisionObjectArray.java} | 24 ++++---- .../BulletCollision/btCollisionWorld.java | 8 +-- .../BulletCollision/btConvexPolyhedron.java | 4 +- .../bullet/BulletCollision/btFace.java | 2 +- ...dexedMesh.java => btIndexedMeshArray.java} | 24 ++++---- ...er.java => btPersistentManifoldArray.java} | 24 ++++---- .../BulletCollision/btQuantizedBvh.java | 6 +- ...Node.java => btQuantizedBvhNodeArray.java} | 24 ++++---- .../btTriangleIndexVertexArray.java | 2 +- .../BulletDynamics/btBatchedConstraints.java | 6 +- .../btDiscreteDynamicsWorld.java | 2 +- .../bullet/BulletDynamics/btMultiBody.java | 60 +++++++++---------- .../btMultiBodyJacobianData.java | 12 ++-- ...BodyPointer.java => btRigidBodyArray.java} | 24 ++++---- ...btSequentialImpulseConstraintSolverMt.java | 12 ++-- .../btDeformableBackwardEulerObjective.java | 34 +++++------ .../btDeformableBodySolver.java | 6 +- .../btDeformableLagrangianForce.java | 16 ++--- .../btDeformableMultiBodyDynamicsWorld.java | 2 +- .../bullet/BulletSoftBody/btSoftBody.java | 46 +++++++------- ...Anchor.java => btSoftBodyAnchorArray.java} | 24 ++++---- ...tBodyPointer.java => btSoftBodyArray.java} | 24 ++++---- ...inter.java => btSoftBodyClusterArray.java} | 24 ++++---- ...ody_Face.java => btSoftBodyFaceArray.java} | 24 ++++---- ...Pointer.java => btSoftBodyJointArray.java} | 24 ++++---- ...ody_Link.java => btSoftBodyLinkArray.java} | 24 ++++---- ...nter.java => btSoftBodyMaterialArray.java} | 24 ++++---- ...ody_Node.java => btSoftBodyNodeArray.java} | 24 ++++---- ...ody_Note.java => btSoftBodyNoteArray.java} | 24 ++++---- ...tact.java => btSoftBodyRContactArray.java} | 24 ++++---- ...ce.java => btSoftBodyRenderFaceArray.java} | 24 ++++---- ...de.java => btSoftBodyRenderNodeArray.java} | 24 ++++---- ...tact.java => btSoftBodySContactArray.java} | 24 ++++---- .../BulletSoftBody/btSoftBodySolver.java | 4 +- ...y_Tetra.java => btSoftBodyTetraArray.java} | 24 ++++---- .../btSoftMultiBodyDynamicsWorld.java | 2 +- .../btSoftRigidDynamicsWorld.java | 2 +- ...ObjectArray_bool.java => btBoolArray.java} | 24 ++++---- ...ObjectArray_char.java => btCharArray.java} | 24 ++++---- ...edObjectArray_int.java => btIntArray.java} | 24 ++++---- ...btMatrix3x3.java => btMatrix3x3Array.java} | 24 ++++---- ...Quaternion.java => btQuaternionArray.java} | 24 ++++---- ...Array_btScalar.java => btScalarArray.java} | 24 ++++---- ...ray_btVector3.java => btVector3Array.java} | 24 ++++---- ...ray_btVector4.java => btVector4Array.java} | 24 ++++---- .../bullet/global/BulletCollision.java | 10 ++-- .../bullet/global/BulletDynamics.java | 2 +- .../bullet/global/BulletSoftBody.java | 28 ++++----- .../bytedeco/bullet/global/LinearMath.java | 16 ++--- 51 files changed, 478 insertions(+), 478 deletions(-) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{btAlignedObjectArray_btBvhSubtreeInfo.java => btBvhSubtreeInfoArray.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{btAlignedObjectArray_btCollisionObjectPointer.java => btCollisionObjectArray.java} (71%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{btAlignedObjectArray_btIndexedMesh.java => btIndexedMeshArray.java} (72%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{btAlignedObjectArray_btPersistentManifoldPointer.java => btPersistentManifoldArray.java} (71%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{btAlignedObjectArray_btQuantizedBvhNode.java => btQuantizedBvhNodeArray.java} (71%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/{btAlignedObjectArray_btRigidBodyPointer.java => btRigidBodyArray.java} (74%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_Anchor.java => btSoftBodyAnchorArray.java} (72%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBodyPointer.java => btSoftBodyArray.java} (75%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_ClusterPointer.java => btSoftBodyClusterArray.java} (72%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_Face.java => btSoftBodyFaceArray.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_JointPointer.java => btSoftBodyJointArray.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_Link.java => btSoftBodyLinkArray.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_MaterialPointer.java => btSoftBodyMaterialArray.java} (72%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_Node.java => btSoftBodyNodeArray.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_Note.java => btSoftBodyNoteArray.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_RContact.java => btSoftBodyRContactArray.java} (72%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_RenderFace.java => btSoftBodyRenderFaceArray.java} (72%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_RenderNode.java => btSoftBodyRenderNodeArray.java} (72%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_SContact.java => btSoftBodySContactArray.java} (72%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/{btAlignedObjectArray_btSoftBody_Tetra.java => btSoftBodyTetraArray.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/LinearMath/{btAlignedObjectArray_bool.java => btBoolArray.java} (77%) rename bullet/src/gen/java/org/bytedeco/bullet/LinearMath/{btAlignedObjectArray_char.java => btCharArray.java} (75%) rename bullet/src/gen/java/org/bytedeco/bullet/LinearMath/{btAlignedObjectArray_int.java => btIntArray.java} (74%) rename bullet/src/gen/java/org/bytedeco/bullet/LinearMath/{btAlignedObjectArray_btMatrix3x3.java => btMatrix3x3Array.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/LinearMath/{btAlignedObjectArray_btQuaternion.java => btQuaternionArray.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/LinearMath/{btAlignedObjectArray_btScalar.java => btScalarArray.java} (74%) rename bullet/src/gen/java/org/bytedeco/bullet/LinearMath/{btAlignedObjectArray_btVector3.java => btVector3Array.java} (73%) rename bullet/src/gen/java/org/bytedeco/bullet/LinearMath/{btAlignedObjectArray_btVector4.java => btVector4Array.java} (73%) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoArray.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoArray.java index 3c043b36c7f..c587db25522 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoArray.java @@ -17,27 +17,27 @@ /**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btAlignedObjectArray_btBvhSubtreeInfo extends Pointer { +public class btBvhSubtreeInfoArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btBvhSubtreeInfo(Pointer p) { super(p); } + public btBvhSubtreeInfoArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btBvhSubtreeInfo(long size) { super((Pointer)null); allocateArray(size); } + public btBvhSubtreeInfoArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btBvhSubtreeInfo position(long position) { - return (btAlignedObjectArray_btBvhSubtreeInfo)super.position(position); + @Override public btBvhSubtreeInfoArray position(long position) { + return (btBvhSubtreeInfoArray)super.position(position); } - @Override public btAlignedObjectArray_btBvhSubtreeInfo getPointer(long i) { - return new btAlignedObjectArray_btBvhSubtreeInfo((Pointer)this).offsetAddress(i); + @Override public btBvhSubtreeInfoArray getPointer(long i) { + return new btBvhSubtreeInfoArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btBvhSubtreeInfo put(@Const @ByRef btAlignedObjectArray_btBvhSubtreeInfo other); - public btAlignedObjectArray_btBvhSubtreeInfo() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btBvhSubtreeInfoArray put(@Const @ByRef btBvhSubtreeInfoArray other); + public btBvhSubtreeInfoArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btBvhSubtreeInfo(@Const @ByRef btAlignedObjectArray_btBvhSubtreeInfo otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btBvhSubtreeInfo otherArray); + public btBvhSubtreeInfoArray(@Const @ByRef btBvhSubtreeInfoArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btBvhSubtreeInfoArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btBvhSubtreeInfo extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btBvhSubtreeInfo otherArray); + public native void copyFromArray(@Const @ByRef btBvhSubtreeInfoArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java index 6dcf7d7e95b..6ba6199c94d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionAlgorithm.java @@ -26,5 +26,5 @@ public class btCollisionAlgorithm extends Pointer { public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); - public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btAlignedObjectArray_btPersistentManifoldPointer manifoldArray); + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectArray.java similarity index 71% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectArray.java index 18822566cf8..8007b4e94b4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectArray.java @@ -13,27 +13,27 @@ import static org.bytedeco.bullet.global.BulletCollision.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btAlignedObjectArray_btCollisionObjectPointer extends Pointer { +public class btCollisionObjectArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btCollisionObjectPointer(Pointer p) { super(p); } + public btCollisionObjectArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btCollisionObjectPointer(long size) { super((Pointer)null); allocateArray(size); } + public btCollisionObjectArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btCollisionObjectPointer position(long position) { - return (btAlignedObjectArray_btCollisionObjectPointer)super.position(position); + @Override public btCollisionObjectArray position(long position) { + return (btCollisionObjectArray)super.position(position); } - @Override public btAlignedObjectArray_btCollisionObjectPointer getPointer(long i) { - return new btAlignedObjectArray_btCollisionObjectPointer((Pointer)this).offsetAddress(i); + @Override public btCollisionObjectArray getPointer(long i) { + return new btCollisionObjectArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btCollisionObjectPointer put(@Const @ByRef btAlignedObjectArray_btCollisionObjectPointer other); - public btAlignedObjectArray_btCollisionObjectPointer() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btCollisionObjectArray put(@Const @ByRef btCollisionObjectArray other); + public btCollisionObjectArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btCollisionObjectPointer(@Const @ByRef btAlignedObjectArray_btCollisionObjectPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btCollisionObjectPointer otherArray); + public btCollisionObjectArray(@Const @ByRef btCollisionObjectArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btCollisionObjectArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -84,5 +84,5 @@ public class btAlignedObjectArray_btCollisionObjectPointer extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btCollisionObjectPointer otherArray); + public native void copyFromArray(@Const @ByRef btCollisionObjectArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java index ab623077445..0827ce59bf9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorld.java @@ -143,9 +143,9 @@ private native void allocate(@Const btCollisionObject collisionObject, public native @ByRef btVector3 m_rayFromWorld(); public native AllHitsRayResultCallback m_rayFromWorld(btVector3 setter); //used to calculate hitPointWorld from hitFraction public native @ByRef btVector3 m_rayToWorld(); public native AllHitsRayResultCallback m_rayToWorld(btVector3 setter); - public native @ByRef btAlignedObjectArray_btVector3 m_hitNormalWorld(); public native AllHitsRayResultCallback m_hitNormalWorld(btAlignedObjectArray_btVector3 setter); - public native @ByRef btAlignedObjectArray_btVector3 m_hitPointWorld(); public native AllHitsRayResultCallback m_hitPointWorld(btAlignedObjectArray_btVector3 setter); - public native @ByRef btAlignedObjectArray_btScalar m_hitFractions(); public native AllHitsRayResultCallback m_hitFractions(btAlignedObjectArray_btScalar setter); + public native @ByRef btVector3Array m_hitNormalWorld(); public native AllHitsRayResultCallback m_hitNormalWorld(btVector3Array setter); + public native @ByRef btVector3Array m_hitPointWorld(); public native AllHitsRayResultCallback m_hitPointWorld(btVector3Array setter); + public native @ByRef btScalarArray m_hitFractions(); public native AllHitsRayResultCallback m_hitFractions(btScalarArray setter); public native @Cast("btScalar") float addSingleResult(@ByRef LocalRayResult rayResult, @Cast("bool") boolean normalInWorldSpace); } @@ -271,7 +271,7 @@ public static native void objectQuerySingleInternal(@Const btConvexShape castSha public native void refreshBroadphaseProxy(btCollisionObject collisionObject); - public native @Cast("btCollisionObjectArray*") @ByRef btAlignedObjectArray_btCollisionObjectPointer getCollisionObjectArray(); + public native @ByRef btCollisionObjectArray getCollisionObjectArray(); public native void removeCollisionObject(btCollisionObject collisionObject); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java index 27af221fcf0..00a6c1aba33 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java @@ -32,9 +32,9 @@ public class btConvexPolyhedron extends Pointer { public btConvexPolyhedron() { super((Pointer)null); allocate(); } private native void allocate(); - public native @ByRef btAlignedObjectArray_btVector3 m_vertices(); public native btConvexPolyhedron m_vertices(btAlignedObjectArray_btVector3 setter); + public native @ByRef btVector3Array m_vertices(); public native btConvexPolyhedron m_vertices(btVector3Array setter); - public native @ByRef btAlignedObjectArray_btVector3 m_uniqueEdges(); public native btConvexPolyhedron m_uniqueEdges(btAlignedObjectArray_btVector3 setter); + public native @ByRef btVector3Array m_uniqueEdges(); public native btConvexPolyhedron m_uniqueEdges(btVector3Array setter); public native @ByRef btVector3 m_localCenter(); public native btConvexPolyhedron m_localCenter(btVector3 setter); public native @ByRef btVector3 m_extents(); public native btConvexPolyhedron m_extents(btVector3 setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java index 64d2a4ca494..f7db9f7a127 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFace.java @@ -31,7 +31,7 @@ public class btFace extends Pointer { return new btFace((Pointer)this).offsetAddress(i); } - public native @ByRef btAlignedObjectArray_int m_indices(); public native btFace m_indices(btAlignedObjectArray_int setter); + public native @ByRef btIntArray m_indices(); public native btFace m_indices(btIntArray setter); // btAlignedObjectArray m_connectedFaces; public native @Cast("btScalar") float m_plane(int i); public native btFace m_plane(int i, float setter); @MemberGetter public native @Cast("btScalar*") FloatPointer m_plane(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btIndexedMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMeshArray.java similarity index 72% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btIndexedMesh.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMeshArray.java index 97325ce5881..bcc76b78293 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btIndexedMesh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btIndexedMeshArray.java @@ -13,27 +13,27 @@ import static org.bytedeco.bullet.global.BulletCollision.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btAlignedObjectArray_btIndexedMesh extends Pointer { +public class btIndexedMeshArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btIndexedMesh(Pointer p) { super(p); } + public btIndexedMeshArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btIndexedMesh(long size) { super((Pointer)null); allocateArray(size); } + public btIndexedMeshArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btIndexedMesh position(long position) { - return (btAlignedObjectArray_btIndexedMesh)super.position(position); + @Override public btIndexedMeshArray position(long position) { + return (btIndexedMeshArray)super.position(position); } - @Override public btAlignedObjectArray_btIndexedMesh getPointer(long i) { - return new btAlignedObjectArray_btIndexedMesh((Pointer)this).offsetAddress(i); + @Override public btIndexedMeshArray getPointer(long i) { + return new btIndexedMeshArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btIndexedMesh put(@Const @ByRef btAlignedObjectArray_btIndexedMesh other); - public btAlignedObjectArray_btIndexedMesh() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btIndexedMeshArray put(@Const @ByRef btIndexedMeshArray other); + public btIndexedMeshArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btIndexedMesh(@Const @ByRef btAlignedObjectArray_btIndexedMesh otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btIndexedMesh otherArray); + public btIndexedMeshArray(@Const @ByRef btIndexedMeshArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btIndexedMeshArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -84,5 +84,5 @@ public class btAlignedObjectArray_btIndexedMesh extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btIndexedMesh otherArray); + public native void copyFromArray(@Const @ByRef btIndexedMeshArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldArray.java similarity index 71% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldArray.java index 7613187434e..1c069330292 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPersistentManifoldArray.java @@ -13,27 +13,27 @@ import static org.bytedeco.bullet.global.BulletCollision.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btAlignedObjectArray_btPersistentManifoldPointer extends Pointer { +public class btPersistentManifoldArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btPersistentManifoldPointer(Pointer p) { super(p); } + public btPersistentManifoldArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btPersistentManifoldPointer(long size) { super((Pointer)null); allocateArray(size); } + public btPersistentManifoldArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btPersistentManifoldPointer position(long position) { - return (btAlignedObjectArray_btPersistentManifoldPointer)super.position(position); + @Override public btPersistentManifoldArray position(long position) { + return (btPersistentManifoldArray)super.position(position); } - @Override public btAlignedObjectArray_btPersistentManifoldPointer getPointer(long i) { - return new btAlignedObjectArray_btPersistentManifoldPointer((Pointer)this).offsetAddress(i); + @Override public btPersistentManifoldArray getPointer(long i) { + return new btPersistentManifoldArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btPersistentManifoldPointer put(@Const @ByRef btAlignedObjectArray_btPersistentManifoldPointer other); - public btAlignedObjectArray_btPersistentManifoldPointer() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btPersistentManifoldArray put(@Const @ByRef btPersistentManifoldArray other); + public btPersistentManifoldArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btPersistentManifoldPointer(@Const @ByRef btAlignedObjectArray_btPersistentManifoldPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btPersistentManifoldPointer otherArray); + public btPersistentManifoldArray(@Const @ByRef btPersistentManifoldArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btPersistentManifoldArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -84,5 +84,5 @@ public class btAlignedObjectArray_btPersistentManifoldPointer extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btPersistentManifoldPointer otherArray); + public native void copyFromArray(@Const @ByRef btPersistentManifoldArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java index 4039f45b4ea..d534a1855e8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvh.java @@ -43,7 +43,7 @@ public class btQuantizedBvh extends Pointer { ///***************************************** expert/internal use only ************************* public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("btScalar") float quantizationMargin/*=btScalar(1.0)*/); public native void setQuantizationValues(@Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); - public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btQuantizedBvhNode getLeafNodeArray(); + public native @Cast("QuantizedNodeArray*") @ByRef btQuantizedBvhNodeArray getLeafNodeArray(); /**buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized */ public native void buildInternal(); ///***************************************** expert/internal use only ************************* @@ -67,9 +67,9 @@ public class btQuantizedBvh extends Pointer { /**setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees. */ public native void setTraversalMode(@Cast("btQuantizedBvh::btTraversalMode") int traversalMode); - public native @Cast("QuantizedNodeArray*") @ByRef btAlignedObjectArray_btQuantizedBvhNode getQuantizedNodeArray(); + public native @Cast("QuantizedNodeArray*") @ByRef btQuantizedBvhNodeArray getQuantizedNodeArray(); - public native @Cast("BvhSubtreeInfoArray*") @ByRef btAlignedObjectArray_btBvhSubtreeInfo getSubtreeInfoArray(); + public native @Cast("BvhSubtreeInfoArray*") @ByRef btBvhSubtreeInfoArray getSubtreeInfoArray(); //////////////////////////////////////////////////////////////////// diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeArray.java similarity index 71% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeArray.java index a09c96292d8..693f5912e32 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhNodeArray.java @@ -13,27 +13,27 @@ import static org.bytedeco.bullet.global.BulletCollision.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btAlignedObjectArray_btQuantizedBvhNode extends Pointer { +public class btQuantizedBvhNodeArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btQuantizedBvhNode(Pointer p) { super(p); } + public btQuantizedBvhNodeArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btQuantizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } + public btQuantizedBvhNodeArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btQuantizedBvhNode position(long position) { - return (btAlignedObjectArray_btQuantizedBvhNode)super.position(position); + @Override public btQuantizedBvhNodeArray position(long position) { + return (btQuantizedBvhNodeArray)super.position(position); } - @Override public btAlignedObjectArray_btQuantizedBvhNode getPointer(long i) { - return new btAlignedObjectArray_btQuantizedBvhNode((Pointer)this).offsetAddress(i); + @Override public btQuantizedBvhNodeArray getPointer(long i) { + return new btQuantizedBvhNodeArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btQuantizedBvhNode put(@Const @ByRef btAlignedObjectArray_btQuantizedBvhNode other); - public btAlignedObjectArray_btQuantizedBvhNode() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btQuantizedBvhNodeArray put(@Const @ByRef btQuantizedBvhNodeArray other); + public btQuantizedBvhNodeArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btQuantizedBvhNode(@Const @ByRef btAlignedObjectArray_btQuantizedBvhNode otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btQuantizedBvhNode otherArray); + public btQuantizedBvhNodeArray(@Const @ByRef btQuantizedBvhNodeArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btQuantizedBvhNodeArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -84,5 +84,5 @@ public class btAlignedObjectArray_btQuantizedBvhNode extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btQuantizedBvhNode otherArray); + public native void copyFromArray(@Const @ByRef btQuantizedBvhNodeArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java index 871bae11ccf..0a19eba1fed 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexArray.java @@ -73,7 +73,7 @@ public class btTriangleIndexVertexArray extends btStridingMeshInterface { * each subpart has a continuous array of vertices and indices */ public native int getNumSubParts(); - public native @Cast("IndexedMeshArray*") @ByRef btAlignedObjectArray_btIndexedMesh getIndexedMeshArray(); + public native @Cast("IndexedMeshArray*") @ByRef btIndexedMeshArray getIndexedMeshArray(); public native void preallocateVertices(int numverts); public native void preallocateIndices(int numindices); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java index 341411ff10d..a92887876a2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java @@ -58,11 +58,11 @@ public class btBatchedConstraints extends Pointer { private native void allocate(int _beg, int _end); } - public native @ByRef btAlignedObjectArray_int m_constraintIndices(); public native btBatchedConstraints m_constraintIndices(btAlignedObjectArray_int setter); + public native @ByRef btIntArray m_constraintIndices(); public native btBatchedConstraints m_constraintIndices(btIntArray setter); // each batch is a range of indices in the m_constraintIndices array // each phase is range of indices in the m_batches array - public native @ByRef btAlignedObjectArray_char m_phaseGrainSize(); public native btBatchedConstraints m_phaseGrainSize(btAlignedObjectArray_char setter); // max grain size for each phase - public native @ByRef btAlignedObjectArray_int m_phaseOrder(); public native btBatchedConstraints m_phaseOrder(btAlignedObjectArray_int setter); // phases can be done in any order, so we can randomize the order here + public native @ByRef btCharArray m_phaseGrainSize(); public native btBatchedConstraints m_phaseGrainSize(btCharArray setter); // max grain size for each phase + public native @ByRef btIntArray m_phaseOrder(); public native btBatchedConstraints m_phaseOrder(btIntArray setter); // phases can be done in any order, so we can randomize the order here public native btIDebugDraw m_debugDrawer(); public native btBatchedConstraints m_debugDrawer(btIDebugDraw setter); public static native @Cast("bool") boolean s_debugDrawBatches(); public static native void s_debugDrawBatches(boolean setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java index fdba271f3a3..022256fb4dd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDiscreteDynamicsWorld.java @@ -117,5 +117,5 @@ public class btDiscreteDynamicsWorld extends btDynamicsWorld { public native void setLatencyMotionStateInterpolation(@Cast("bool") boolean latencyInterpolation); public native @Cast("bool") boolean getLatencyMotionStateInterpolation(); - public native @ByRef btAlignedObjectArray_btRigidBodyPointer getNonStaticRigidBodies(); + public native @ByRef btRigidBodyArray getNonStaticRigidBodies(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java index 8163fe32e86..7da42b3554b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBody.java @@ -306,9 +306,9 @@ public native void setupPlanar(int i, // public native void computeAccelerationsArticulatedBodyAlgorithmMultiDof(@Cast("btScalar") float dt, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v, - @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m, + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v, + @ByRef btMatrix3x3Array scratch_m, @Cast("bool") boolean isConstraintPass, @Cast("bool") boolean jointFeedbackInWorldSpace, @Cast("bool") boolean jointFeedbackInJointFrame @@ -331,14 +331,14 @@ public native void computeAccelerationsArticulatedBodyAlgorithmMultiDof(@Cast("b // (existing contents of output array are replaced) // calcAccelerationDeltasMultiDof must have been called first. public native void calcAccelerationDeltasMultiDof(@Cast("const btScalar*") FloatPointer force, @Cast("btScalar*") FloatPointer output, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v); public native void calcAccelerationDeltasMultiDof(@Cast("const btScalar*") FloatBuffer force, @Cast("btScalar*") FloatBuffer output, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v); public native void calcAccelerationDeltasMultiDof(@Cast("const btScalar*") float[] force, @Cast("btScalar*") float[] output, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v); public native void applyDeltaVeeMultiDof2(@Cast("const btScalar*") FloatPointer delta_vee, @Cast("btScalar") float multiplier); public native void applyDeltaVeeMultiDof2(@Cast("const btScalar*") FloatBuffer delta_vee, @Cast("btScalar") float multiplier); @@ -375,23 +375,23 @@ public native void fillContactJacobianMultiDof(int link, @Const @ByRef btVector3 contact_point, @Const @ByRef btVector3 normal, @Cast("btScalar*") FloatPointer jac, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v, - @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v, + @ByRef btMatrix3x3Array scratch_m); public native void fillContactJacobianMultiDof(int link, @Const @ByRef btVector3 contact_point, @Const @ByRef btVector3 normal, @Cast("btScalar*") FloatBuffer jac, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v, - @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v, + @ByRef btMatrix3x3Array scratch_m); public native void fillContactJacobianMultiDof(int link, @Const @ByRef btVector3 contact_point, @Const @ByRef btVector3 normal, @Cast("btScalar*") float[] jac, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v, - @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v, + @ByRef btMatrix3x3Array scratch_m); //a more general version of fillContactJacobianMultiDof which does not assume.. //.. that the constraint in question is contact or, to be more precise, constrains linear velocity only @@ -400,25 +400,25 @@ public native void fillConstraintJacobianMultiDof(int link, @Const @ByRef btVector3 normal_ang, @Const @ByRef btVector3 normal_lin, @Cast("btScalar*") FloatPointer jac, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v, - @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v, + @ByRef btMatrix3x3Array scratch_m); public native void fillConstraintJacobianMultiDof(int link, @Const @ByRef btVector3 contact_point, @Const @ByRef btVector3 normal_ang, @Const @ByRef btVector3 normal_lin, @Cast("btScalar*") FloatBuffer jac, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v, - @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v, + @ByRef btMatrix3x3Array scratch_m); public native void fillConstraintJacobianMultiDof(int link, @Const @ByRef btVector3 contact_point, @Const @ByRef btVector3 normal_ang, @Const @ByRef btVector3 normal_lin, @Cast("btScalar*") float[] jac, - @ByRef btAlignedObjectArray_btScalar scratch_r, - @ByRef btAlignedObjectArray_btVector3 scratch_v, - @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m); + @ByRef btScalarArray scratch_r, + @ByRef btVector3Array scratch_v, + @ByRef btMatrix3x3Array scratch_m); // // sleeping @@ -478,12 +478,12 @@ public native void fillConstraintJacobianMultiDof(int link, //internalNeedsJointFeedback is for internal use only public native @Cast("bool") boolean internalNeedsJointFeedback(); - public native void forwardKinematics(@ByRef btAlignedObjectArray_btQuaternion world_to_local, @ByRef btAlignedObjectArray_btVector3 local_origin); + public native void forwardKinematics(@ByRef btQuaternionArray world_to_local, @ByRef btVector3Array local_origin); public native void compTreeLinkVelocities(btVector3 omega, btVector3 vel); - public native void updateCollisionObjectWorldTransforms(@ByRef btAlignedObjectArray_btQuaternion world_to_local, @ByRef btAlignedObjectArray_btVector3 local_origin); - public native void updateCollisionObjectInterpolationWorldTransforms(@ByRef btAlignedObjectArray_btQuaternion world_to_local, @ByRef btAlignedObjectArray_btVector3 local_origin); + public native void updateCollisionObjectWorldTransforms(@ByRef btQuaternionArray world_to_local, @ByRef btVector3Array local_origin); + public native void updateCollisionObjectInterpolationWorldTransforms(@ByRef btQuaternionArray world_to_local, @ByRef btVector3Array local_origin); public native int calculateSerializeBufferSize(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java index 960ff4af5ae..4de49719f6d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java @@ -33,12 +33,12 @@ public class btMultiBodyJacobianData extends Pointer { return new btMultiBodyJacobianData((Pointer)this).offsetAddress(i); } - public native @ByRef btAlignedObjectArray_btScalar m_jacobians(); public native btMultiBodyJacobianData m_jacobians(btAlignedObjectArray_btScalar setter); - public native @ByRef btAlignedObjectArray_btScalar m_deltaVelocitiesUnitImpulse(); public native btMultiBodyJacobianData m_deltaVelocitiesUnitImpulse(btAlignedObjectArray_btScalar setter); //holds the joint-space response of the corresp. tree to the test impulse in each constraint space dimension - public native @ByRef btAlignedObjectArray_btScalar m_deltaVelocities(); public native btMultiBodyJacobianData m_deltaVelocities(btAlignedObjectArray_btScalar setter); //holds joint-space vectors of all the constrained trees accumulating the effect of corrective impulses applied in SI - public native @ByRef btAlignedObjectArray_btScalar scratch_r(); public native btMultiBodyJacobianData scratch_r(btAlignedObjectArray_btScalar setter); - public native @ByRef btAlignedObjectArray_btVector3 scratch_v(); public native btMultiBodyJacobianData scratch_v(btAlignedObjectArray_btVector3 setter); - public native @ByRef btAlignedObjectArray_btMatrix3x3 scratch_m(); public native btMultiBodyJacobianData scratch_m(btAlignedObjectArray_btMatrix3x3 setter); + public native @ByRef btScalarArray m_jacobians(); public native btMultiBodyJacobianData m_jacobians(btScalarArray setter); + public native @ByRef btScalarArray m_deltaVelocitiesUnitImpulse(); public native btMultiBodyJacobianData m_deltaVelocitiesUnitImpulse(btScalarArray setter); //holds the joint-space response of the corresp. tree to the test impulse in each constraint space dimension + public native @ByRef btScalarArray m_deltaVelocities(); public native btMultiBodyJacobianData m_deltaVelocities(btScalarArray setter); //holds joint-space vectors of all the constrained trees accumulating the effect of corrective impulses applied in SI + public native @ByRef btScalarArray scratch_r(); public native btMultiBodyJacobianData scratch_r(btScalarArray setter); + public native @ByRef btVector3Array scratch_v(); public native btMultiBodyJacobianData scratch_v(btVector3Array setter); + public native @ByRef btMatrix3x3Array scratch_m(); public native btMultiBodyJacobianData scratch_m(btMatrix3x3Array setter); public native int m_fixedBodyId(); public native btMultiBodyJacobianData m_fixedBodyId(int setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyArray.java similarity index 74% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyArray.java index cd7618c00de..9ecfcd1341f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyArray.java @@ -19,27 +19,27 @@ /**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) -public class btAlignedObjectArray_btRigidBodyPointer extends Pointer { +public class btRigidBodyArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btRigidBodyPointer(Pointer p) { super(p); } + public btRigidBodyArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btRigidBodyPointer(long size) { super((Pointer)null); allocateArray(size); } + public btRigidBodyArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btRigidBodyPointer position(long position) { - return (btAlignedObjectArray_btRigidBodyPointer)super.position(position); + @Override public btRigidBodyArray position(long position) { + return (btRigidBodyArray)super.position(position); } - @Override public btAlignedObjectArray_btRigidBodyPointer getPointer(long i) { - return new btAlignedObjectArray_btRigidBodyPointer((Pointer)this).offsetAddress(i); + @Override public btRigidBodyArray getPointer(long i) { + return new btRigidBodyArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btRigidBodyPointer put(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer other); - public btAlignedObjectArray_btRigidBodyPointer() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btRigidBodyArray put(@Const @ByRef btRigidBodyArray other); + public btRigidBodyArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btRigidBodyPointer(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); + public btRigidBodyArray(@Const @ByRef btRigidBodyArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btRigidBodyArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -90,5 +90,5 @@ public class btAlignedObjectArray_btRigidBodyPointer extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btRigidBodyPointer otherArray); + public native void copyFromArray(@Const @ByRef btRigidBodyArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java index 32a5563bc25..56161a0ab23 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java @@ -140,12 +140,12 @@ public static class JointParams extends Pointer { public btSequentialImpulseConstraintSolverMt() { super((Pointer)null); allocate(); } private native void allocate(); - public native @Cast("btScalar") float resolveMultipleJointConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd, int iteration); - public native @Cast("btScalar") float resolveMultipleContactConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd); - public native @Cast("btScalar") float resolveMultipleContactSplitPenetrationImpulseConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd); - public native @Cast("btScalar") float resolveMultipleContactFrictionConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd); - public native @Cast("btScalar") float resolveMultipleContactRollingFrictionConstraints(@Const @ByRef btAlignedObjectArray_int consIndices, int batchBegin, int batchEnd); - public native @Cast("btScalar") float resolveMultipleContactConstraintsInterleaved(@Const @ByRef btAlignedObjectArray_int contactIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleJointConstraints(@Const @ByRef btIntArray consIndices, int batchBegin, int batchEnd, int iteration); + public native @Cast("btScalar") float resolveMultipleContactConstraints(@Const @ByRef btIntArray consIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleContactSplitPenetrationImpulseConstraints(@Const @ByRef btIntArray consIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleContactFrictionConstraints(@Const @ByRef btIntArray consIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleContactRollingFrictionConstraints(@Const @ByRef btIntArray consIndices, int batchBegin, int batchEnd); + public native @Cast("btScalar") float resolveMultipleContactConstraintsInterleaved(@Const @ByRef btIntArray contactIndices, int batchBegin, int batchEnd); public native void internalCollectContactManifoldCachedInfo(btContactManifoldCachedInfo cachedInfoArray, @Cast("btPersistentManifold**") PointerPointer manifoldPtr, int numManifolds, @Const @ByRef btContactSolverInfo infoGlobal); public native void internalCollectContactManifoldCachedInfo(btContactManifoldCachedInfo cachedInfoArray, @ByPtrPtr btPersistentManifold manifoldPtr, int numManifolds, @Const @ByRef btContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java index 83c23c0b568..65730a25d69 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java @@ -25,40 +25,40 @@ public class btDeformableBackwardEulerObjective extends Pointer { public native @Cast("btScalar") float m_dt(); public native btDeformableBackwardEulerObjective m_dt(float setter); - public native @ByRef btAlignedObjectArray_btSoftBodyPointer m_softBodies(); public native btDeformableBackwardEulerObjective m_softBodies(btAlignedObjectArray_btSoftBodyPointer setter); + public native @ByRef btSoftBodyArray m_softBodies(); public native btDeformableBackwardEulerObjective m_softBodies(btSoftBodyArray setter); - @MemberGetter public native @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 m_backupVelocity(); + @MemberGetter public native @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array m_backupVelocity(); public native @Cast("bool") boolean m_implicit(); public native btDeformableBackwardEulerObjective m_implicit(boolean setter); - public btDeformableBackwardEulerObjective(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 backup_v) { super((Pointer)null); allocate(softBodies, backup_v); } - private native void allocate(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 backup_v); + public btDeformableBackwardEulerObjective(@ByRef btSoftBodyArray softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array backup_v) { super((Pointer)null); allocate(softBodies, backup_v); } + private native void allocate(@ByRef btSoftBodyArray softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array backup_v); public native void initialize(); // compute the rhs for CG solve, i.e, add the dt scaled implicit force to residual - public native void computeResidual(@Cast("btScalar") float dt, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual); + public native void computeResidual(@Cast("btScalar") float dt, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array residual); // add explicit force to the velocity - public native void applyExplicitForce(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 force); + public native void applyExplicitForce(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array force); // apply force to velocity and optionally reset the force to zero - public native void applyForce(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 force, @Cast("bool") boolean setZero); + public native void applyForce(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array force, @Cast("bool") boolean setZero); // compute the norm of the residual - public native @Cast("btScalar") float computeNorm(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual); + public native @Cast("btScalar") float computeNorm(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array residual); // compute one step of the solve (there is only one solve if the system is linear) // perform A*x = b - public native void multiply(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 b); + public native void multiply(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array b); // set initial guess for CG solve - public native void initialGuess(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual); + public native void initialGuess(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array residual); // reset data structure and reset dt public native void reinitialize(@Cast("bool") boolean nodeUpdated, @Cast("btScalar") float dt); @@ -66,19 +66,19 @@ public class btDeformableBackwardEulerObjective extends Pointer { public native void setDt(@Cast("btScalar") float dt); // add friction force to residual - public native void applyDynamicFriction(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 r); + public native void applyDynamicFriction(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array r); // add dv to velocity - public native void updateVelocity(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv); + public native void updateVelocity(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array dv); //set constraints as projections public native void setConstraints(@Const @ByRef btContactSolverInfo infoGlobal); // update the projections and project the residual - public native void project(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 r); + public native void project(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array r); // perform precondition M^(-1) x = b - public native void precondition(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 b); + public native void precondition(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array b); // reindex all the vertices public native void updateId(); @@ -90,9 +90,9 @@ public class btDeformableBackwardEulerObjective extends Pointer { // Calculate the total potential energy in the system public native @Cast("btScalar") float totalEnergy(@Cast("btScalar") float dt); - public native void addLagrangeMultiplier(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 vec, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 extended_vec); + public native void addLagrangeMultiplier(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array vec, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array extended_vec); - public native void addLagrangeMultiplierRHS(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 residual, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 m_dv, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 extended_residual); + public native void addLagrangeMultiplierRHS(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array residual, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array m_dv, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array extended_residual); - public native void calculateContactForce(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 rhs, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btAlignedObjectArray_btVector3 f); + public native void calculateContactForce(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array rhs, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array f); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java index f7bfca41c01..439daccf871 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java @@ -51,7 +51,7 @@ public class btDeformableBodySolver extends btSoftBodySolver { public native void solveDeformableConstraints(@Cast("btScalar") float solverdt); // resize/clear data structures - public native void reinitialize(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("btScalar") float dt); + public native void reinitialize(@Const @ByRef btSoftBodyArray softBodies, @Cast("btScalar") float dt); // set up contact constraints public native void setConstraints(@Const @ByRef btContactSolverInfo infoGlobal); @@ -128,8 +128,8 @@ public class btDeformableBodySolver extends btSoftBodySolver { public native @Cast("btScalar") float kineticEnergy(); // unused functions - public native void optimize(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("bool") boolean forceUpdate/*=false*/); - public native void optimize(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies); + public native void optimize(@ByRef btSoftBodyArray softBodies, @Cast("bool") boolean forceUpdate/*=false*/); + public native void optimize(@ByRef btSoftBodyArray softBodies); public native void solveConstraints(@Cast("btScalar") float dt); public native @Cast("bool") boolean checkInitialized(); public native void copyBackToSoftBodies(@Cast("bool") boolean bMove/*=true*/); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java index e3ee2dcb600..3f3cad3bcd9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java @@ -23,26 +23,26 @@ public class btDeformableLagrangianForce extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btDeformableLagrangianForce(Pointer p) { super(p); } - public native @ByRef btAlignedObjectArray_btSoftBodyPointer m_softBodies(); public native btDeformableLagrangianForce m_softBodies(btAlignedObjectArray_btSoftBodyPointer setter); + public native @ByRef btSoftBodyArray m_softBodies(); public native btDeformableLagrangianForce m_softBodies(btSoftBodyArray setter); // add all forces - public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 force); + public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array force); // add damping df - public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 dv, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 df); + public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array dv, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array df); // build diagonal of A matrix - public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 diagA); + public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array diagA); // add elastic df - public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 dx, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 df); + public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array dx, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array df); // add all forces that are explicit in explicit solve - public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 force); + public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array force); // add all damping forces - public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 force); + public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array force); public native void addScaledHessian(@Cast("btScalar") float scale); @@ -61,7 +61,7 @@ public class btDeformableLagrangianForce extends Pointer { // Calculate the incremental deformable generated from the input dx - public native @ByVal btMatrix3x3 Ds(int id0, int id1, int id2, int id3, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btAlignedObjectArray_btVector3 dx); + public native @ByVal btMatrix3x3 Ds(int id0, int id1, int id2, int id3, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array dx); // Calculate the incremental deformable generated from the current velocity public native @ByVal btMatrix3x3 DsFromVelocity(@Const btSoftBody.Node n0, @Const btSoftBody.Node n1, @Const btSoftBody.Node n2, @Const btSoftBody.Node n3); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java index 8bdbcb9da43..f260da0bf0c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java @@ -44,7 +44,7 @@ public class btDeformableMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld public native void addSoftBody(btSoftBody body, int collisionFilterGroup/*=btBroadphaseProxy::DefaultFilter*/, int collisionFilterMask/*=btBroadphaseProxy::AllFilter*/); public native void addSoftBody(btSoftBody body); - public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBodyPointer getSoftBodyArray(); + public native @ByRef btSoftBodyArray getSoftBodyArray(); public native @ByRef btSoftBodyWorldInfo getWorldInfo(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java index 248ce89ce15..30589eff54a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java @@ -729,8 +729,8 @@ public static class Pose extends Pointer { public native @Cast("bool") boolean m_bvolume(); public native Pose m_bvolume(boolean setter); // Is valid public native @Cast("bool") boolean m_bframe(); public native Pose m_bframe(boolean setter); // Is frame public native @Cast("btScalar") float m_volume(); public native Pose m_volume(float setter); // Rest volume - public native @ByRef @Cast("btSoftBody::tVector3Array*") btAlignedObjectArray_btVector3 m_pos(); public native Pose m_pos(btAlignedObjectArray_btVector3 setter); // Reference positions - public native @ByRef @Cast("btSoftBody::tScalarArray*") btAlignedObjectArray_btScalar m_wgh(); public native Pose m_wgh(btAlignedObjectArray_btScalar setter); // Weights + public native @ByRef @Cast("btSoftBody::tVector3Array*") btVector3Array m_pos(); public native Pose m_pos(btVector3Array setter); // Reference positions + public native @ByRef @Cast("btSoftBody::tScalarArray*") btScalarArray m_wgh(); public native Pose m_wgh(btScalarArray setter); // Weights public native @ByRef btVector3 m_com(); public native Pose m_com(btVector3 setter); // COM public native @ByRef btMatrix3x3 m_rot(); public native Pose m_rot(btMatrix3x3 setter); // Rotation public native @ByRef btMatrix3x3 m_scl(); public native Pose m_scl(btMatrix3x3 setter); // Scale @@ -751,9 +751,9 @@ public static class Pose extends Pointer { return new Cluster((Pointer)this).offsetAddress(i); } - public native @ByRef @Cast("btSoftBody::tScalarArray*") btAlignedObjectArray_btScalar m_masses(); public native Cluster m_masses(btAlignedObjectArray_btScalar setter); + public native @ByRef @Cast("btSoftBody::tScalarArray*") btScalarArray m_masses(); public native Cluster m_masses(btScalarArray setter); - public native @ByRef @Cast("btSoftBody::tVector3Array*") btAlignedObjectArray_btVector3 m_framerefs(); public native Cluster m_framerefs(btAlignedObjectArray_btVector3 setter); + public native @ByRef @Cast("btSoftBody::tVector3Array*") btVector3Array m_framerefs(); public native Cluster m_framerefs(btVector3Array setter); public native @ByRef btTransform m_framexform(); public native Cluster m_framexform(btTransform setter); public native @Cast("btScalar") float m_idmass(); public native Cluster m_idmass(float setter); public native @Cast("btScalar") float m_imass(); public native Cluster m_imass(float setter); @@ -1130,24 +1130,24 @@ public static class vsolver_t extends FunctionPointer { public native @ByRef Pose m_pose(); public native btSoftBody m_pose(Pose setter); // Pose public native Pointer m_tag(); public native btSoftBody m_tag(Pointer setter); // User data public native btSoftBodyWorldInfo m_worldInfo(); public native btSoftBody m_worldInfo(btSoftBodyWorldInfo setter); // World info - public native @ByRef @Cast("btSoftBody::tNoteArray*") btAlignedObjectArray_btSoftBody_Note m_notes(); public native btSoftBody m_notes(btAlignedObjectArray_btSoftBody_Note setter); // Notes - public native @ByRef @Cast("btSoftBody::tNodeArray*") btAlignedObjectArray_btSoftBody_Node m_nodes(); public native btSoftBody m_nodes(btAlignedObjectArray_btSoftBody_Node setter); // Nodes - public native @ByRef @Cast("btSoftBody::tRenderNodeArray*") btAlignedObjectArray_btSoftBody_RenderNode m_renderNodes(); public native btSoftBody m_renderNodes(btAlignedObjectArray_btSoftBody_RenderNode setter); // Render Nodes - public native @ByRef @Cast("btSoftBody::tLinkArray*") btAlignedObjectArray_btSoftBody_Link m_links(); public native btSoftBody m_links(btAlignedObjectArray_btSoftBody_Link setter); // Links - public native @ByRef @Cast("btSoftBody::tFaceArray*") btAlignedObjectArray_btSoftBody_Face m_faces(); public native btSoftBody m_faces(btAlignedObjectArray_btSoftBody_Face setter); // Faces - public native @ByRef @Cast("btSoftBody::tRenderFaceArray*") btAlignedObjectArray_btSoftBody_RenderFace m_renderFaces(); public native btSoftBody m_renderFaces(btAlignedObjectArray_btSoftBody_RenderFace setter); // Faces - public native @ByRef @Cast("btSoftBody::tTetraArray*") btAlignedObjectArray_btSoftBody_Tetra m_tetras(); public native btSoftBody m_tetras(btAlignedObjectArray_btSoftBody_Tetra setter); // Tetras + public native @ByRef @Cast("btSoftBody::tNoteArray*") btSoftBodyNoteArray m_notes(); public native btSoftBody m_notes(btSoftBodyNoteArray setter); // Notes + public native @ByRef @Cast("btSoftBody::tNodeArray*") btSoftBodyNodeArray m_nodes(); public native btSoftBody m_nodes(btSoftBodyNodeArray setter); // Nodes + public native @ByRef @Cast("btSoftBody::tRenderNodeArray*") btSoftBodyRenderNodeArray m_renderNodes(); public native btSoftBody m_renderNodes(btSoftBodyRenderNodeArray setter); // Render Nodes + public native @ByRef @Cast("btSoftBody::tLinkArray*") btSoftBodyLinkArray m_links(); public native btSoftBody m_links(btSoftBodyLinkArray setter); // Links + public native @ByRef @Cast("btSoftBody::tFaceArray*") btSoftBodyFaceArray m_faces(); public native btSoftBody m_faces(btSoftBodyFaceArray setter); // Faces + public native @ByRef @Cast("btSoftBody::tRenderFaceArray*") btSoftBodyRenderFaceArray m_renderFaces(); public native btSoftBody m_renderFaces(btSoftBodyRenderFaceArray setter); // Faces + public native @ByRef @Cast("btSoftBody::tTetraArray*") btSoftBodyTetraArray m_tetras(); public native btSoftBody m_tetras(btSoftBodyTetraArray setter); // Tetras - public native @ByRef @Cast("btSoftBody::tAnchorArray*") btAlignedObjectArray_btSoftBody_Anchor m_anchors(); public native btSoftBody m_anchors(btAlignedObjectArray_btSoftBody_Anchor setter); // Anchors + public native @ByRef @Cast("btSoftBody::tAnchorArray*") btSoftBodyAnchorArray m_anchors(); public native btSoftBody m_anchors(btSoftBodyAnchorArray setter); // Anchors - public native @ByRef @Cast("btSoftBody::tRContactArray*") btAlignedObjectArray_btSoftBody_RContact m_rcontacts(); public native btSoftBody m_rcontacts(btAlignedObjectArray_btSoftBody_RContact setter); // Rigid contacts + public native @ByRef @Cast("btSoftBody::tRContactArray*") btSoftBodyRContactArray m_rcontacts(); public native btSoftBody m_rcontacts(btSoftBodyRContactArray setter); // Rigid contacts - public native @ByRef @Cast("btSoftBody::tSContactArray*") btAlignedObjectArray_btSoftBody_SContact m_scontacts(); public native btSoftBody m_scontacts(btAlignedObjectArray_btSoftBody_SContact setter); // Soft contacts - public native @ByRef @Cast("btSoftBody::tJointArray*") btAlignedObjectArray_btSoftBody_JointPointer m_joints(); public native btSoftBody m_joints(btAlignedObjectArray_btSoftBody_JointPointer setter); // Joints - public native @ByRef @Cast("btSoftBody::tMaterialArray*") btAlignedObjectArray_btSoftBody_MaterialPointer m_materials(); public native btSoftBody m_materials(btAlignedObjectArray_btSoftBody_MaterialPointer setter); // Materials + public native @ByRef @Cast("btSoftBody::tSContactArray*") btSoftBodySContactArray m_scontacts(); public native btSoftBody m_scontacts(btSoftBodySContactArray setter); // Soft contacts + public native @ByRef @Cast("btSoftBody::tJointArray*") btSoftBodyJointArray m_joints(); public native btSoftBody m_joints(btSoftBodyJointArray setter); // Joints + public native @ByRef @Cast("btSoftBody::tMaterialArray*") btSoftBodyMaterialArray m_materials(); public native btSoftBody m_materials(btSoftBodyMaterialArray setter); // Materials public native @Cast("btScalar") float m_timeacc(); public native btSoftBody m_timeacc(float setter); // Time accumulator public native @ByRef btVector3 m_bounds(int i); public native btSoftBody m_bounds(int i, btVector3 setter); @MemberGetter public native btVector3 m_bounds(); // Spatial bounds @@ -1156,23 +1156,23 @@ public static class vsolver_t extends FunctionPointer { public native @ByRef btDbvt m_fdbvt(); public native btSoftBody m_fdbvt(btDbvt setter); // Faces tree // Faces tree with normals public native @ByRef btDbvt m_cdbvt(); public native btSoftBody m_cdbvt(btDbvt setter); // Clusters tree - public native @ByRef @Cast("btSoftBody::tClusterArray*") btAlignedObjectArray_btSoftBody_ClusterPointer m_clusters(); public native btSoftBody m_clusters(btAlignedObjectArray_btSoftBody_ClusterPointer setter); // Clusters + public native @ByRef @Cast("btSoftBody::tClusterArray*") btSoftBodyClusterArray m_clusters(); public native btSoftBody m_clusters(btSoftBodyClusterArray setter); // Clusters public native @Cast("btScalar") float m_dampingCoefficient(); public native btSoftBody m_dampingCoefficient(float setter); // Damping Coefficient public native @Cast("btScalar") float m_sleepingThreshold(); public native btSoftBody m_sleepingThreshold(float setter); public native @Cast("btScalar") float m_maxSpeedSquared(); public native btSoftBody m_maxSpeedSquared(float setter); - public native @ByRef btAlignedObjectArray_btVector3 m_quads(); public native btSoftBody m_quads(btAlignedObjectArray_btVector3 setter); // quadrature points for collision detection + public native @ByRef btVector3Array m_quads(); public native btSoftBody m_quads(btVector3Array setter); // quadrature points for collision detection public native @Cast("btScalar") float m_repulsionStiffness(); public native btSoftBody m_repulsionStiffness(float setter); public native @Cast("btScalar") float m_gravityFactor(); public native btSoftBody m_gravityFactor(float setter); public native @Cast("bool") boolean m_cacheBarycenter(); public native btSoftBody m_cacheBarycenter(boolean setter); - public native @ByRef btAlignedObjectArray_btVector3 m_X(); public native btSoftBody m_X(btAlignedObjectArray_btVector3 setter); // initial positions + public native @ByRef btVector3Array m_X(); public native btSoftBody m_X(btVector3Array setter); // initial positions - public native @ByRef btAlignedObjectArray_btVector4 m_renderNodesInterpolationWeights(); public native btSoftBody m_renderNodesInterpolationWeights(btAlignedObjectArray_btVector4 setter); + public native @ByRef btVector4Array m_renderNodesInterpolationWeights(); public native btSoftBody m_renderNodesInterpolationWeights(btVector4Array setter); - public native @ByRef btAlignedObjectArray_btScalar m_z(); public native btSoftBody m_z(btAlignedObjectArray_btScalar setter); // vertical distance used in extrapolation + public native @ByRef btScalarArray m_z(); public native btSoftBody m_z(btScalarArray setter); // vertical distance used in extrapolation public native @Cast("bool") boolean m_useSelfCollision(); public native btSoftBody m_useSelfCollision(boolean setter); public native @Cast("bool") boolean m_softSoftCollision(); public native btSoftBody m_softSoftCollision(boolean setter); - public native @ByRef btAlignedObjectArray_bool m_clusterConnectivity(); public native btSoftBody m_clusterConnectivity(btAlignedObjectArray_bool setter); //cluster connectivity, for self-collision + public native @ByRef btBoolArray m_clusterConnectivity(); public native btSoftBody m_clusterConnectivity(btBoolArray setter); //cluster connectivity, for self-collision public native @ByRef btVector3 m_windVelocity(); public native btSoftBody m_windVelocity(btVector3 setter); @@ -1199,7 +1199,7 @@ public static class vsolver_t extends FunctionPointer { /* dtor */ /* Check for existing link */ - public native @ByRef btAlignedObjectArray_int m_userIndexMapping(); public native btSoftBody m_userIndexMapping(btAlignedObjectArray_int setter); + public native @ByRef btIntArray m_userIndexMapping(); public native btSoftBody m_userIndexMapping(btIntArray setter); public native btSoftBodyWorldInfo getWorldInfo(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyAnchorArray.java similarity index 72% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyAnchorArray.java index 39e11da8a26..6f5d1dc398e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyAnchorArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_Anchor extends Pointer { +public class btSoftBodyAnchorArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_Anchor(Pointer p) { super(p); } + public btSoftBodyAnchorArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_Anchor(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyAnchorArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_Anchor position(long position) { - return (btAlignedObjectArray_btSoftBody_Anchor)super.position(position); + @Override public btSoftBodyAnchorArray position(long position) { + return (btSoftBodyAnchorArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_Anchor getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_Anchor((Pointer)this).offsetAddress(i); + @Override public btSoftBodyAnchorArray getPointer(long i) { + return new btSoftBodyAnchorArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Anchor put(@Const @ByRef btAlignedObjectArray_btSoftBody_Anchor other); - public btAlignedObjectArray_btSoftBody_Anchor() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyAnchorArray put(@Const @ByRef btSoftBodyAnchorArray other); + public btSoftBodyAnchorArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_Anchor(@Const @ByRef btAlignedObjectArray_btSoftBody_Anchor otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Anchor otherArray); + public btSoftBodyAnchorArray(@Const @ByRef btSoftBodyAnchorArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyAnchorArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_Anchor extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Anchor otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyAnchorArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBodyPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyArray.java similarity index 75% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBodyPointer.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyArray.java index c208e1a0bd8..82d8a57350c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBodyPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyArray.java @@ -21,27 +21,27 @@ /**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBodyPointer extends Pointer { +public class btSoftBodyArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBodyPointer(Pointer p) { super(p); } + public btSoftBodyArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBodyPointer(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBodyPointer position(long position) { - return (btAlignedObjectArray_btSoftBodyPointer)super.position(position); + @Override public btSoftBodyArray position(long position) { + return (btSoftBodyArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBodyPointer getPointer(long i) { - return new btAlignedObjectArray_btSoftBodyPointer((Pointer)this).offsetAddress(i); + @Override public btSoftBodyArray getPointer(long i) { + return new btSoftBodyArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBodyPointer put(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer other); - public btAlignedObjectArray_btSoftBodyPointer() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyArray put(@Const @ByRef btSoftBodyArray other); + public btSoftBodyArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBodyPointer(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer otherArray); + public btSoftBodyArray(@Const @ByRef btSoftBodyArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -92,5 +92,5 @@ public class btAlignedObjectArray_btSoftBodyPointer extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBodyPointer otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyClusterArray.java similarity index 72% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyClusterArray.java index 08b7c72c5a8..84db9d947d0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyClusterArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_ClusterPointer extends Pointer { +public class btSoftBodyClusterArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_ClusterPointer(Pointer p) { super(p); } + public btSoftBodyClusterArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_ClusterPointer(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyClusterArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_ClusterPointer position(long position) { - return (btAlignedObjectArray_btSoftBody_ClusterPointer)super.position(position); + @Override public btSoftBodyClusterArray position(long position) { + return (btSoftBodyClusterArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_ClusterPointer getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_ClusterPointer((Pointer)this).offsetAddress(i); + @Override public btSoftBodyClusterArray getPointer(long i) { + return new btSoftBodyClusterArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_ClusterPointer put(@Const @ByRef btAlignedObjectArray_btSoftBody_ClusterPointer other); - public btAlignedObjectArray_btSoftBody_ClusterPointer() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyClusterArray put(@Const @ByRef btSoftBodyClusterArray other); + public btSoftBodyClusterArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_ClusterPointer(@Const @ByRef btAlignedObjectArray_btSoftBody_ClusterPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_ClusterPointer otherArray); + public btSoftBodyClusterArray(@Const @ByRef btSoftBodyClusterArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyClusterArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_ClusterPointer extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_ClusterPointer otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyClusterArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyFaceArray.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyFaceArray.java index 798b768d58b..f802ddf8726 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyFaceArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_Face extends Pointer { +public class btSoftBodyFaceArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_Face(Pointer p) { super(p); } + public btSoftBodyFaceArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_Face(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyFaceArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_Face position(long position) { - return (btAlignedObjectArray_btSoftBody_Face)super.position(position); + @Override public btSoftBodyFaceArray position(long position) { + return (btSoftBodyFaceArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_Face getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_Face((Pointer)this).offsetAddress(i); + @Override public btSoftBodyFaceArray getPointer(long i) { + return new btSoftBodyFaceArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Face put(@Const @ByRef btAlignedObjectArray_btSoftBody_Face other); - public btAlignedObjectArray_btSoftBody_Face() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyFaceArray put(@Const @ByRef btSoftBodyFaceArray other); + public btSoftBodyFaceArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_Face(@Const @ByRef btAlignedObjectArray_btSoftBody_Face otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Face otherArray); + public btSoftBodyFaceArray(@Const @ByRef btSoftBodyFaceArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyFaceArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_Face extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Face otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyFaceArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyJointArray.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyJointArray.java index 7845e39fa06..b7f488714ef 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyJointArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_JointPointer extends Pointer { +public class btSoftBodyJointArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_JointPointer(Pointer p) { super(p); } + public btSoftBodyJointArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_JointPointer(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyJointArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_JointPointer position(long position) { - return (btAlignedObjectArray_btSoftBody_JointPointer)super.position(position); + @Override public btSoftBodyJointArray position(long position) { + return (btSoftBodyJointArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_JointPointer getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_JointPointer((Pointer)this).offsetAddress(i); + @Override public btSoftBodyJointArray getPointer(long i) { + return new btSoftBodyJointArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_JointPointer put(@Const @ByRef btAlignedObjectArray_btSoftBody_JointPointer other); - public btAlignedObjectArray_btSoftBody_JointPointer() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyJointArray put(@Const @ByRef btSoftBodyJointArray other); + public btSoftBodyJointArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_JointPointer(@Const @ByRef btAlignedObjectArray_btSoftBody_JointPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_JointPointer otherArray); + public btSoftBodyJointArray(@Const @ByRef btSoftBodyJointArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyJointArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_JointPointer extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_JointPointer otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyJointArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkArray.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkArray.java index d611c8dd684..1e53d2bf900 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_Link extends Pointer { +public class btSoftBodyLinkArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_Link(Pointer p) { super(p); } + public btSoftBodyLinkArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_Link(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyLinkArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_Link position(long position) { - return (btAlignedObjectArray_btSoftBody_Link)super.position(position); + @Override public btSoftBodyLinkArray position(long position) { + return (btSoftBodyLinkArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_Link getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_Link((Pointer)this).offsetAddress(i); + @Override public btSoftBodyLinkArray getPointer(long i) { + return new btSoftBodyLinkArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Link put(@Const @ByRef btAlignedObjectArray_btSoftBody_Link other); - public btAlignedObjectArray_btSoftBody_Link() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyLinkArray put(@Const @ByRef btSoftBodyLinkArray other); + public btSoftBodyLinkArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_Link(@Const @ByRef btAlignedObjectArray_btSoftBody_Link otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Link otherArray); + public btSoftBodyLinkArray(@Const @ByRef btSoftBodyLinkArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyLinkArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_Link extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Link otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyLinkArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyMaterialArray.java similarity index 72% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyMaterialArray.java index 7ee22d1fab3..f9a589b6827 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyMaterialArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_MaterialPointer extends Pointer { +public class btSoftBodyMaterialArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_MaterialPointer(Pointer p) { super(p); } + public btSoftBodyMaterialArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_MaterialPointer(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyMaterialArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_MaterialPointer position(long position) { - return (btAlignedObjectArray_btSoftBody_MaterialPointer)super.position(position); + @Override public btSoftBodyMaterialArray position(long position) { + return (btSoftBodyMaterialArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_MaterialPointer getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_MaterialPointer((Pointer)this).offsetAddress(i); + @Override public btSoftBodyMaterialArray getPointer(long i) { + return new btSoftBodyMaterialArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_MaterialPointer put(@Const @ByRef btAlignedObjectArray_btSoftBody_MaterialPointer other); - public btAlignedObjectArray_btSoftBody_MaterialPointer() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyMaterialArray put(@Const @ByRef btSoftBodyMaterialArray other); + public btSoftBodyMaterialArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_MaterialPointer(@Const @ByRef btAlignedObjectArray_btSoftBody_MaterialPointer otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_MaterialPointer otherArray); + public btSoftBodyMaterialArray(@Const @ByRef btSoftBodyMaterialArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyMaterialArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_MaterialPointer extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_MaterialPointer otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyMaterialArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNodeArray.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNodeArray.java index 957249614b5..cb7550270f0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNodeArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_Node extends Pointer { +public class btSoftBodyNodeArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_Node(Pointer p) { super(p); } + public btSoftBodyNodeArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_Node(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyNodeArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_Node position(long position) { - return (btAlignedObjectArray_btSoftBody_Node)super.position(position); + @Override public btSoftBodyNodeArray position(long position) { + return (btSoftBodyNodeArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_Node getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_Node((Pointer)this).offsetAddress(i); + @Override public btSoftBodyNodeArray getPointer(long i) { + return new btSoftBodyNodeArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Node put(@Const @ByRef btAlignedObjectArray_btSoftBody_Node other); - public btAlignedObjectArray_btSoftBody_Node() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyNodeArray put(@Const @ByRef btSoftBodyNodeArray other); + public btSoftBodyNodeArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_Node(@Const @ByRef btAlignedObjectArray_btSoftBody_Node otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Node otherArray); + public btSoftBodyNodeArray(@Const @ByRef btSoftBodyNodeArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyNodeArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_Node extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Node otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyNodeArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNoteArray.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNoteArray.java index d1b43577ddc..6dd218bb4c3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNoteArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_Note extends Pointer { +public class btSoftBodyNoteArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_Note(Pointer p) { super(p); } + public btSoftBodyNoteArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_Note(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyNoteArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_Note position(long position) { - return (btAlignedObjectArray_btSoftBody_Note)super.position(position); + @Override public btSoftBodyNoteArray position(long position) { + return (btSoftBodyNoteArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_Note getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_Note((Pointer)this).offsetAddress(i); + @Override public btSoftBodyNoteArray getPointer(long i) { + return new btSoftBodyNoteArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Note put(@Const @ByRef btAlignedObjectArray_btSoftBody_Note other); - public btAlignedObjectArray_btSoftBody_Note() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyNoteArray put(@Const @ByRef btSoftBodyNoteArray other); + public btSoftBodyNoteArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_Note(@Const @ByRef btAlignedObjectArray_btSoftBody_Note otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Note otherArray); + public btSoftBodyNoteArray(@Const @ByRef btSoftBodyNoteArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyNoteArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_Note extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Note otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyNoteArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRContactArray.java similarity index 72% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRContactArray.java index c95d6101c6f..1b8cb5a40bb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRContactArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_RContact extends Pointer { +public class btSoftBodyRContactArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_RContact(Pointer p) { super(p); } + public btSoftBodyRContactArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_RContact(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyRContactArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_RContact position(long position) { - return (btAlignedObjectArray_btSoftBody_RContact)super.position(position); + @Override public btSoftBodyRContactArray position(long position) { + return (btSoftBodyRContactArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_RContact getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_RContact((Pointer)this).offsetAddress(i); + @Override public btSoftBodyRContactArray getPointer(long i) { + return new btSoftBodyRContactArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_RContact put(@Const @ByRef btAlignedObjectArray_btSoftBody_RContact other); - public btAlignedObjectArray_btSoftBody_RContact() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyRContactArray put(@Const @ByRef btSoftBodyRContactArray other); + public btSoftBodyRContactArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_RContact(@Const @ByRef btAlignedObjectArray_btSoftBody_RContact otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_RContact otherArray); + public btSoftBodyRContactArray(@Const @ByRef btSoftBodyRContactArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyRContactArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_RContact extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_RContact otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyRContactArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRenderFaceArray.java similarity index 72% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRenderFaceArray.java index 148064c9f62..3453975590c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRenderFaceArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_RenderFace extends Pointer { +public class btSoftBodyRenderFaceArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_RenderFace(Pointer p) { super(p); } + public btSoftBodyRenderFaceArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_RenderFace(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyRenderFaceArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_RenderFace position(long position) { - return (btAlignedObjectArray_btSoftBody_RenderFace)super.position(position); + @Override public btSoftBodyRenderFaceArray position(long position) { + return (btSoftBodyRenderFaceArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_RenderFace getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_RenderFace((Pointer)this).offsetAddress(i); + @Override public btSoftBodyRenderFaceArray getPointer(long i) { + return new btSoftBodyRenderFaceArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_RenderFace put(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderFace other); - public btAlignedObjectArray_btSoftBody_RenderFace() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyRenderFaceArray put(@Const @ByRef btSoftBodyRenderFaceArray other); + public btSoftBodyRenderFaceArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_RenderFace(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderFace otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderFace otherArray); + public btSoftBodyRenderFaceArray(@Const @ByRef btSoftBodyRenderFaceArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyRenderFaceArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_RenderFace extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderFace otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyRenderFaceArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRenderNodeArray.java similarity index 72% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRenderNodeArray.java index da33e3ab40c..be17ae2de1a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyRenderNodeArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_RenderNode extends Pointer { +public class btSoftBodyRenderNodeArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_RenderNode(Pointer p) { super(p); } + public btSoftBodyRenderNodeArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_RenderNode(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyRenderNodeArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_RenderNode position(long position) { - return (btAlignedObjectArray_btSoftBody_RenderNode)super.position(position); + @Override public btSoftBodyRenderNodeArray position(long position) { + return (btSoftBodyRenderNodeArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_RenderNode getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_RenderNode((Pointer)this).offsetAddress(i); + @Override public btSoftBodyRenderNodeArray getPointer(long i) { + return new btSoftBodyRenderNodeArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_RenderNode put(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderNode other); - public btAlignedObjectArray_btSoftBody_RenderNode() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyRenderNodeArray put(@Const @ByRef btSoftBodyRenderNodeArray other); + public btSoftBodyRenderNodeArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_RenderNode(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderNode otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderNode otherArray); + public btSoftBodyRenderNodeArray(@Const @ByRef btSoftBodyRenderNodeArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyRenderNodeArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_RenderNode extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_RenderNode otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyRenderNodeArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySContactArray.java similarity index 72% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySContactArray.java index f0769df2fa3..a28e2254e6b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySContactArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_SContact extends Pointer { +public class btSoftBodySContactArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_SContact(Pointer p) { super(p); } + public btSoftBodySContactArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_SContact(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodySContactArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_SContact position(long position) { - return (btAlignedObjectArray_btSoftBody_SContact)super.position(position); + @Override public btSoftBodySContactArray position(long position) { + return (btSoftBodySContactArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_SContact getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_SContact((Pointer)this).offsetAddress(i); + @Override public btSoftBodySContactArray getPointer(long i) { + return new btSoftBodySContactArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_SContact put(@Const @ByRef btAlignedObjectArray_btSoftBody_SContact other); - public btAlignedObjectArray_btSoftBody_SContact() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodySContactArray put(@Const @ByRef btSoftBodySContactArray other); + public btSoftBodySContactArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_SContact(@Const @ByRef btAlignedObjectArray_btSoftBody_SContact otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_SContact otherArray); + public btSoftBodySContactArray(@Const @ByRef btSoftBodySContactArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodySContactArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_SContact extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_SContact otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodySContactArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java index fe207207cc4..36e9b3ce84a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodySolver.java @@ -48,8 +48,8 @@ public enum SolverTypes { public native @Cast("bool") boolean checkInitialized(); /** Optimize soft bodies in this solver. */ - public native void optimize(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies, @Cast("bool") boolean forceUpdate/*=false*/); - public native void optimize(@ByRef btAlignedObjectArray_btSoftBodyPointer softBodies); + public native void optimize(@ByRef btSoftBodyArray softBodies, @Cast("bool") boolean forceUpdate/*=false*/); + public native void optimize(@ByRef btSoftBodyArray softBodies); /** Copy necessary data back to the original soft body source objects. */ public native void copyBackToSoftBodies(@Cast("bool") boolean bMove/*=true*/); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTetraArray.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTetraArray.java index 136a4ef1d5d..e307ccba5ff 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTetraArray.java @@ -17,27 +17,27 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btAlignedObjectArray_btSoftBody_Tetra extends Pointer { +public class btSoftBodyTetraArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btSoftBody_Tetra(Pointer p) { super(p); } + public btSoftBodyTetraArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btSoftBody_Tetra(long size) { super((Pointer)null); allocateArray(size); } + public btSoftBodyTetraArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btSoftBody_Tetra position(long position) { - return (btAlignedObjectArray_btSoftBody_Tetra)super.position(position); + @Override public btSoftBodyTetraArray position(long position) { + return (btSoftBodyTetraArray)super.position(position); } - @Override public btAlignedObjectArray_btSoftBody_Tetra getPointer(long i) { - return new btAlignedObjectArray_btSoftBody_Tetra((Pointer)this).offsetAddress(i); + @Override public btSoftBodyTetraArray getPointer(long i) { + return new btSoftBodyTetraArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btSoftBody_Tetra put(@Const @ByRef btAlignedObjectArray_btSoftBody_Tetra other); - public btAlignedObjectArray_btSoftBody_Tetra() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btSoftBodyTetraArray put(@Const @ByRef btSoftBodyTetraArray other); + public btSoftBodyTetraArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btSoftBody_Tetra(@Const @ByRef btAlignedObjectArray_btSoftBody_Tetra otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btSoftBody_Tetra otherArray); + public btSoftBodyTetraArray(@Const @ByRef btSoftBodyTetraArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyTetraArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -88,5 +88,5 @@ public class btAlignedObjectArray_btSoftBody_Tetra extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btSoftBody_Tetra otherArray); + public native void copyFromArray(@Const @ByRef btSoftBodyTetraArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java index 282c9fd8f2e..aeb687555fd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftMultiBodyDynamicsWorld.java @@ -46,7 +46,7 @@ public class btSoftMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld { public native @Cast("btDynamicsWorldType") int getWorldType(); - public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBodyPointer getSoftBodyArray(); + public native @ByRef btSoftBodyArray getSoftBodyArray(); public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java index 22dd64da0dd..5ad45aa6643 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidDynamicsWorld.java @@ -45,7 +45,7 @@ public class btSoftRigidDynamicsWorld extends btDiscreteDynamicsWorld { public native @Cast("btDynamicsWorldType") int getWorldType(); - public native @Cast("btSoftBodyArray*") @ByRef btAlignedObjectArray_btSoftBodyPointer getSoftBodyArray(); + public native @ByRef btSoftBodyArray getSoftBodyArray(); public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef RayResultCallback resultCallback); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBoolArray.java similarity index 77% rename from bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java rename to bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBoolArray.java index cd6d0720d74..7153bd51027 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_bool.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btBoolArray.java @@ -15,27 +15,27 @@ /**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btAlignedObjectArray_bool extends Pointer { +public class btBoolArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_bool(Pointer p) { super(p); } + public btBoolArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_bool(long size) { super((Pointer)null); allocateArray(size); } + public btBoolArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_bool position(long position) { - return (btAlignedObjectArray_bool)super.position(position); + @Override public btBoolArray position(long position) { + return (btBoolArray)super.position(position); } - @Override public btAlignedObjectArray_bool getPointer(long i) { - return new btAlignedObjectArray_bool((Pointer)this).offsetAddress(i); + @Override public btBoolArray getPointer(long i) { + return new btBoolArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_bool put(@Const @ByRef btAlignedObjectArray_bool other); - public btAlignedObjectArray_bool() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btBoolArray put(@Const @ByRef btBoolArray other); + public btBoolArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_bool(@Const @ByRef btAlignedObjectArray_bool otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_bool otherArray); + public btBoolArray(@Const @ByRef btBoolArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btBoolArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -86,5 +86,5 @@ public class btAlignedObjectArray_bool extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_bool otherArray); + public native void copyFromArray(@Const @ByRef btBoolArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btCharArray.java similarity index 75% rename from bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java rename to bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btCharArray.java index 3216358252c..99d025b61c3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_char.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btCharArray.java @@ -11,27 +11,27 @@ import static org.bytedeco.bullet.global.LinearMath.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btAlignedObjectArray_char extends Pointer { +public class btCharArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_char(Pointer p) { super(p); } + public btCharArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_char(long size) { super((Pointer)null); allocateArray(size); } + public btCharArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_char position(long position) { - return (btAlignedObjectArray_char)super.position(position); + @Override public btCharArray position(long position) { + return (btCharArray)super.position(position); } - @Override public btAlignedObjectArray_char getPointer(long i) { - return new btAlignedObjectArray_char((Pointer)this).offsetAddress(i); + @Override public btCharArray getPointer(long i) { + return new btCharArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_char put(@Const @ByRef btAlignedObjectArray_char other); - public btAlignedObjectArray_char() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btCharArray put(@Const @ByRef btCharArray other); + public btCharArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_char(@Const @ByRef btAlignedObjectArray_char otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_char otherArray); + public btCharArray(@Const @ByRef btCharArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btCharArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -82,5 +82,5 @@ public class btAlignedObjectArray_char extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_char otherArray); + public native void copyFromArray(@Const @ByRef btCharArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntArray.java similarity index 74% rename from bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java rename to bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntArray.java index 5f3a082c7ee..d392dd6c0be 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_int.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntArray.java @@ -11,27 +11,27 @@ import static org.bytedeco.bullet.global.LinearMath.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btAlignedObjectArray_int extends Pointer { +public class btIntArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_int(Pointer p) { super(p); } + public btIntArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_int(long size) { super((Pointer)null); allocateArray(size); } + public btIntArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_int position(long position) { - return (btAlignedObjectArray_int)super.position(position); + @Override public btIntArray position(long position) { + return (btIntArray)super.position(position); } - @Override public btAlignedObjectArray_int getPointer(long i) { - return new btAlignedObjectArray_int((Pointer)this).offsetAddress(i); + @Override public btIntArray getPointer(long i) { + return new btIntArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_int put(@Const @ByRef btAlignedObjectArray_int other); - public btAlignedObjectArray_int() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btIntArray put(@Const @ByRef btIntArray other); + public btIntArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_int(@Const @ByRef btAlignedObjectArray_int otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_int otherArray); + public btIntArray(@Const @ByRef btIntArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btIntArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -82,5 +82,5 @@ public class btAlignedObjectArray_int extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_int otherArray); + public native void copyFromArray(@Const @ByRef btIntArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3Array.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java rename to bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3Array.java index 3b6eea11f62..1ef6be53de8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btMatrix3x3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrix3x3Array.java @@ -11,27 +11,27 @@ import static org.bytedeco.bullet.global.LinearMath.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btAlignedObjectArray_btMatrix3x3 extends Pointer { +public class btMatrix3x3Array extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btMatrix3x3(Pointer p) { super(p); } + public btMatrix3x3Array(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btMatrix3x3(long size) { super((Pointer)null); allocateArray(size); } + public btMatrix3x3Array(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btMatrix3x3 position(long position) { - return (btAlignedObjectArray_btMatrix3x3)super.position(position); + @Override public btMatrix3x3Array position(long position) { + return (btMatrix3x3Array)super.position(position); } - @Override public btAlignedObjectArray_btMatrix3x3 getPointer(long i) { - return new btAlignedObjectArray_btMatrix3x3((Pointer)this).offsetAddress(i); + @Override public btMatrix3x3Array getPointer(long i) { + return new btMatrix3x3Array((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btMatrix3x3 put(@Const @ByRef btAlignedObjectArray_btMatrix3x3 other); - public btAlignedObjectArray_btMatrix3x3() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btMatrix3x3Array put(@Const @ByRef btMatrix3x3Array other); + public btMatrix3x3Array() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btMatrix3x3(@Const @ByRef btAlignedObjectArray_btMatrix3x3 otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btMatrix3x3 otherArray); + public btMatrix3x3Array(@Const @ByRef btMatrix3x3Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btMatrix3x3Array otherArray); /** return the number of elements in the array */ public native int size(); @@ -82,5 +82,5 @@ public class btAlignedObjectArray_btMatrix3x3 extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btMatrix3x3 otherArray); + public native void copyFromArray(@Const @ByRef btMatrix3x3Array otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionArray.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java rename to bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionArray.java index 94e9398d9f6..242adaa7763 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btQuaternion.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btQuaternionArray.java @@ -11,27 +11,27 @@ import static org.bytedeco.bullet.global.LinearMath.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btAlignedObjectArray_btQuaternion extends Pointer { +public class btQuaternionArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btQuaternion(Pointer p) { super(p); } + public btQuaternionArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btQuaternion(long size) { super((Pointer)null); allocateArray(size); } + public btQuaternionArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btQuaternion position(long position) { - return (btAlignedObjectArray_btQuaternion)super.position(position); + @Override public btQuaternionArray position(long position) { + return (btQuaternionArray)super.position(position); } - @Override public btAlignedObjectArray_btQuaternion getPointer(long i) { - return new btAlignedObjectArray_btQuaternion((Pointer)this).offsetAddress(i); + @Override public btQuaternionArray getPointer(long i) { + return new btQuaternionArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btQuaternion put(@Const @ByRef btAlignedObjectArray_btQuaternion other); - public btAlignedObjectArray_btQuaternion() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btQuaternionArray put(@Const @ByRef btQuaternionArray other); + public btQuaternionArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btQuaternion(@Const @ByRef btAlignedObjectArray_btQuaternion otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btQuaternion otherArray); + public btQuaternionArray(@Const @ByRef btQuaternionArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btQuaternionArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -82,5 +82,5 @@ public class btAlignedObjectArray_btQuaternion extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btQuaternion otherArray); + public native void copyFromArray(@Const @ByRef btQuaternionArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btScalarArray.java similarity index 74% rename from bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java rename to bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btScalarArray.java index c21e5427b38..5abb1c0e6db 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btScalar.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btScalarArray.java @@ -11,27 +11,27 @@ import static org.bytedeco.bullet.global.LinearMath.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btAlignedObjectArray_btScalar extends Pointer { +public class btScalarArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btScalar(Pointer p) { super(p); } + public btScalarArray(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btScalar(long size) { super((Pointer)null); allocateArray(size); } + public btScalarArray(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btScalar position(long position) { - return (btAlignedObjectArray_btScalar)super.position(position); + @Override public btScalarArray position(long position) { + return (btScalarArray)super.position(position); } - @Override public btAlignedObjectArray_btScalar getPointer(long i) { - return new btAlignedObjectArray_btScalar((Pointer)this).offsetAddress(i); + @Override public btScalarArray getPointer(long i) { + return new btScalarArray((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btScalar put(@Const @ByRef btAlignedObjectArray_btScalar other); - public btAlignedObjectArray_btScalar() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btScalarArray put(@Const @ByRef btScalarArray other); + public btScalarArray() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btScalar(@Const @ByRef btAlignedObjectArray_btScalar otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btScalar otherArray); + public btScalarArray(@Const @ByRef btScalarArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btScalarArray otherArray); /** return the number of elements in the array */ public native int size(); @@ -82,5 +82,5 @@ public class btAlignedObjectArray_btScalar extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btScalar otherArray); + public native void copyFromArray(@Const @ByRef btScalarArray otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3Array.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java rename to bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3Array.java index 723034a810d..07bab437930 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector3.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector3Array.java @@ -11,27 +11,27 @@ import static org.bytedeco.bullet.global.LinearMath.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btAlignedObjectArray_btVector3 extends Pointer { +public class btVector3Array extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btVector3(Pointer p) { super(p); } + public btVector3Array(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btVector3(long size) { super((Pointer)null); allocateArray(size); } + public btVector3Array(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btVector3 position(long position) { - return (btAlignedObjectArray_btVector3)super.position(position); + @Override public btVector3Array position(long position) { + return (btVector3Array)super.position(position); } - @Override public btAlignedObjectArray_btVector3 getPointer(long i) { - return new btAlignedObjectArray_btVector3((Pointer)this).offsetAddress(i); + @Override public btVector3Array getPointer(long i) { + return new btVector3Array((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btVector3 put(@Const @ByRef btAlignedObjectArray_btVector3 other); - public btAlignedObjectArray_btVector3() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btVector3Array put(@Const @ByRef btVector3Array other); + public btVector3Array() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btVector3(@Const @ByRef btAlignedObjectArray_btVector3 otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btVector3 otherArray); + public btVector3Array(@Const @ByRef btVector3Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btVector3Array otherArray); /** return the number of elements in the array */ public native int size(); @@ -82,5 +82,5 @@ public class btAlignedObjectArray_btVector3 extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btVector3 otherArray); + public native void copyFromArray(@Const @ByRef btVector3Array otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4Array.java similarity index 73% rename from bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java rename to bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4Array.java index 4582a07f586..18e8377f128 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedObjectArray_btVector4.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVector4Array.java @@ -11,27 +11,27 @@ import static org.bytedeco.bullet.global.LinearMath.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) -public class btAlignedObjectArray_btVector4 extends Pointer { +public class btVector4Array extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btAlignedObjectArray_btVector4(Pointer p) { super(p); } + public btVector4Array(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btAlignedObjectArray_btVector4(long size) { super((Pointer)null); allocateArray(size); } + public btVector4Array(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public btAlignedObjectArray_btVector4 position(long position) { - return (btAlignedObjectArray_btVector4)super.position(position); + @Override public btVector4Array position(long position) { + return (btVector4Array)super.position(position); } - @Override public btAlignedObjectArray_btVector4 getPointer(long i) { - return new btAlignedObjectArray_btVector4((Pointer)this).offsetAddress(i); + @Override public btVector4Array getPointer(long i) { + return new btVector4Array((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") btAlignedObjectArray_btVector4 put(@Const @ByRef btAlignedObjectArray_btVector4 other); - public btAlignedObjectArray_btVector4() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") btVector4Array put(@Const @ByRef btVector4Array other); + public btVector4Array() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public btAlignedObjectArray_btVector4(@Const @ByRef btAlignedObjectArray_btVector4 otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef btAlignedObjectArray_btVector4 otherArray); + public btVector4Array(@Const @ByRef btVector4Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btVector4Array otherArray); /** return the number of elements in the array */ public native int size(); @@ -82,5 +82,5 @@ public class btAlignedObjectArray_btVector4 extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef btAlignedObjectArray_btVector4 otherArray); + public native void copyFromArray(@Const @ByRef btVector4Array otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index 29f37905982..9065607a1ea 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -55,19 +55,19 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../BulletCollision/btAlignedObjectArray_btBvhSubtreeInfo.java +// Targeting ../BulletCollision/btBvhSubtreeInfoArray.java -// Targeting ../BulletCollision/btAlignedObjectArray_btCollisionObjectPointer.java +// Targeting ../BulletCollision/btCollisionObjectArray.java -// Targeting ../BulletCollision/btAlignedObjectArray_btIndexedMesh.java +// Targeting ../BulletCollision/btIndexedMeshArray.java -// Targeting ../BulletCollision/btAlignedObjectArray_btPersistentManifoldPointer.java +// Targeting ../BulletCollision/btPersistentManifoldArray.java -// Targeting ../BulletCollision/btAlignedObjectArray_btQuantizedBvhNode.java +// Targeting ../BulletCollision/btQuantizedBvhNodeArray.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index 68c941e999f..414b9add18e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -57,7 +57,7 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../BulletDynamics/btAlignedObjectArray_btRigidBodyPointer.java +// Targeting ../BulletDynamics/btRigidBodyArray.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index 764879ac791..aa708ea2754 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -59,46 +59,46 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBodyPointer.java +// Targeting ../BulletSoftBody/btSoftBodyArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Anchor.java +// Targeting ../BulletSoftBody/btSoftBodyAnchorArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_ClusterPointer.java +// Targeting ../BulletSoftBody/btSoftBodyClusterArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Face.java +// Targeting ../BulletSoftBody/btSoftBodyFaceArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_JointPointer.java +// Targeting ../BulletSoftBody/btSoftBodyJointArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Link.java +// Targeting ../BulletSoftBody/btSoftBodyLinkArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_MaterialPointer.java +// Targeting ../BulletSoftBody/btSoftBodyMaterialArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Node.java +// Targeting ../BulletSoftBody/btSoftBodyNodeArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Note.java +// Targeting ../BulletSoftBody/btSoftBodyNoteArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RContact.java +// Targeting ../BulletSoftBody/btSoftBodyRContactArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderFace.java +// Targeting ../BulletSoftBody/btSoftBodyRenderFaceArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_RenderNode.java +// Targeting ../BulletSoftBody/btSoftBodyRenderNodeArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_SContact.java +// Targeting ../BulletSoftBody/btSoftBodySContactArray.java -// Targeting ../BulletSoftBody/btAlignedObjectArray_btSoftBody_Tetra.java +// Targeting ../BulletSoftBody/btSoftBodyTetraArray.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index 64dc60cffaa..ec4712bc41f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -716,28 +716,28 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../LinearMath/btAlignedObjectArray_bool.java +// Targeting ../LinearMath/btBoolArray.java -// Targeting ../LinearMath/btAlignedObjectArray_char.java +// Targeting ../LinearMath/btCharArray.java -// Targeting ../LinearMath/btAlignedObjectArray_int.java +// Targeting ../LinearMath/btIntArray.java -// Targeting ../LinearMath/btAlignedObjectArray_btScalar.java +// Targeting ../LinearMath/btScalarArray.java -// Targeting ../LinearMath/btAlignedObjectArray_btMatrix3x3.java +// Targeting ../LinearMath/btMatrix3x3Array.java -// Targeting ../LinearMath/btAlignedObjectArray_btQuaternion.java +// Targeting ../LinearMath/btQuaternionArray.java -// Targeting ../LinearMath/btAlignedObjectArray_btVector3.java +// Targeting ../LinearMath/btVector3Array.java -// Targeting ../LinearMath/btAlignedObjectArray_btVector4.java +// Targeting ../LinearMath/btVector4Array.java From a19894f5e386aa07014cb41dc0182213ffc5698a Mon Sep 17 00:00:00 2001 From: Andrew Date: Thu, 24 Feb 2022 13:43:57 +0800 Subject: [PATCH 37/81] Note on btAlignedObjectArray mappings --- bullet/README.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/bullet/README.md b/bullet/README.md index 86a736cee9a..ade20ba1887 100644 --- a/bullet/README.md +++ b/bullet/README.md @@ -17,6 +17,24 @@ Java API documentation is available here: * http://bytedeco.org/javacpp-presets/bullet/apidocs/ +Special Mappings +---------------- + +Mappings of `btAlignedObjectArray`'s instances for privitime types: + +| C++ | Java | +|----------------------------------|-----------------| +| `btAlignedObjectArray` | `btBoolArray` | +| `btAlignedObjectArray` | `btCharArray` | +| `btAlignedObjectArray` | `btIntArray` | +| `btAlignedObjectArray` | `btScalarArray` | + +Name of a Java class, corresponding to an instance of `btAlignedObjectArray` +for a composite type, is constructed by adding `Array` suffix to the name of +the composite type, e.g. `btAlignedObjectArray` maps to +`btQuaternionArray`. + + Sample Usage ------------ From e2cd37f1cdab67298c445df1a1d4a1065a7f17e1 Mon Sep 17 00:00:00 2001 From: Samuel Audet Date: Mon, 28 Feb 2022 12:07:51 +0900 Subject: [PATCH 38/81] Add builds for linux-x86 and macosx-x86_64 Also fix nits and update CHANGELOG.md --- .github/workflows/bullet.yml | 19 +-- CHANGELOG.md | 1 + README.md | 3 +- bullet/{LICENCE => LICENSE.txt} | 0 bullet/README.md | 132 +++++++++++++++++- bullet/cppbuild.sh | 56 +++++++- bullet/platform/pom.xml | 34 +++-- bullet/samples/pom.xml | 1 + .../bullet/presets/BulletCollision.java | 28 +++- .../bullet/presets/BulletDynamics.java | 28 +++- .../bullet/presets/BulletSoftBody.java | 28 +++- .../bytedeco/bullet/presets/LinearMath.java | 28 +++- cppbuild.sh | 2 +- platform/pom.xml | 12 +- pom.xml | 18 +-- 15 files changed, 337 insertions(+), 53 deletions(-) rename bullet/{LICENCE => LICENSE.txt} (100%) diff --git a/.github/workflows/bullet.yml b/.github/workflows/bullet.yml index 8b4d16b19a7..4c5d32223cd 100644 --- a/.github/workflows/bullet.yml +++ b/.github/workflows/bullet.yml @@ -35,11 +35,20 @@ jobs: container: centos:7 steps: - uses: bytedeco/javacpp-presets/.github/actions/deploy-centos@actions + linux-x86: + runs-on: ubuntu-18.04 + container: centos:7 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-centos@actions linux-x86_64: runs-on: ubuntu-18.04 container: centos:7 steps: - uses: bytedeco/javacpp-presets/.github/actions/deploy-centos@actions + macosx-x86_64: + runs-on: macos-10.15 + steps: + - uses: bytedeco/javacpp-presets/.github/actions/deploy-macosx@actions windows-x86: runs-on: windows-2019 steps: @@ -49,15 +58,7 @@ jobs: steps: - uses: bytedeco/javacpp-presets/.github/actions/deploy-windows@actions redeploy: - needs: [ - android-arm, - android-arm64, - android-x86, - android-x86_64, - linux-x86_64, - windows-x86, - windows-x86_64 - ] + needs: [android-arm, android-arm64, android-x86, android-x86_64, linux-x86, linux-x86_64, macosx-x86_64, windows-x86, windows-x86_64] runs-on: ubuntu-18.04 steps: - uses: bytedeco/javacpp-presets/.github/actions/redeploy@actions diff --git a/CHANGELOG.md b/CHANGELOG.md index 061acff074d..a2eff7b6425 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,5 @@ + * Add presets for Bullet Physics SDK 3.21 ([pull #1153](https://github.com/bytedeco/javacpp-presets/pull/1153)) * Disable signal handlers of DepthAI known to cause issues with the JDK ([issue #1118](https://github.com/bytedeco/javacpp-presets/issues/1118)) * Upgrade presets for Gym 0.22.0, ALE 0.7.4, ONNX 1.11.0, and their dependencies diff --git a/README.md b/README.md index 615fbfea5bc..f820b8acce2 100644 --- a/README.md +++ b/README.md @@ -54,6 +54,7 @@ JavaCPP Presets [![ngraph](https://github.com/bytedeco/javacpp-presets/workflows/ngraph/badge.svg)](https://github.com/bytedeco/javacpp-presets/actions?query=workflow%3Angraph) [![onnxruntime](https://github.com/bytedeco/javacpp-presets/workflows/onnxruntime/badge.svg)](https://github.com/bytedeco/javacpp-presets/actions?query=workflow%3Aonnxruntime) [![tvm](https://github.com/bytedeco/javacpp-presets/workflows/tvm/badge.svg)](https://github.com/bytedeco/javacpp-presets/actions?query=workflow%3Atvm) +[![bullet](https://github.com/bytedeco/javacpp-presets/workflows/bullet/badge.svg)](https://github.com/bytedeco/javacpp-presets/actions?query=workflow%3Abullet) [![liquidfun](https://github.com/bytedeco/javacpp-presets/workflows/liquidfun/badge.svg)](https://github.com/bytedeco/javacpp-presets/actions?query=workflow%3Aliquidfun) [![qt](https://github.com/bytedeco/javacpp-presets/workflows/qt/badge.svg)](https://github.com/bytedeco/javacpp-presets/actions?query=workflow%3Aqt) [![skia](https://github.com/bytedeco/javacpp-presets/workflows/skia/badge.svg)](https://github.com/bytedeco/javacpp-presets/actions?query=workflow%3Askia) @@ -224,6 +225,7 @@ Each child module in turn relies by default on the included [`cppbuild.sh` scrip * nGraph 0.26.0 https://github.com/NervanaSystems/ngraph * ONNX Runtime 1.10.x https://github.com/microsoft/onnxruntime * TVM 0.8.x https://github.com/apache/tvm + * Bullet Physics SDK 3.21 https://pybullet.org * LiquidFun http://google.github.io/liquidfun/ * Qt 5.15.x https://download.qt.io/archive/qt/ * Mono/Skia 2.80.x https://github.com/mono/skia @@ -233,7 +235,6 @@ Each child module in turn relies by default on the included [`cppbuild.sh` scrip * Linux (glibc) https://www.gnu.org/software/libc/ * Mac OS X (XNU libc) https://opensource.apple.com/ * Windows (Win32) https://developer.microsoft.com/en-us/windows/ - * Bullet Physics SDK 3.21 https://pybullet.org/wordpress Once everything installed and configured, simply execute ```bash diff --git a/bullet/LICENCE b/bullet/LICENSE.txt similarity index 100% rename from bullet/LICENCE rename to bullet/LICENSE.txt diff --git a/bullet/README.md b/bullet/README.md index ade20ba1887..69f6a9a80e7 100644 --- a/bullet/README.md +++ b/bullet/README.md @@ -1,6 +1,10 @@ JavaCPP Presets for Bullet Physics SDK ====================================== +[![Gitter](https://badges.gitter.im/bytedeco/javacpp.svg)](https://gitter.im/bytedeco/javacpp) [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.bytedeco/bullet/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.bytedeco/bullet) [![Sonatype Nexus (Snapshots)](https://img.shields.io/nexus/s/https/oss.sonatype.org/org.bytedeco/bullet.svg)](http://bytedeco.org/builds/) +Build status for all platforms: [![bullet](https://github.com/bytedeco/javacpp-presets/workflows/bullet/badge.svg)](https://github.com/bytedeco/javacpp-presets/actions?query=workflow%3Abullet) Commercial support: [![xscode](https://img.shields.io/badge/Available%20on-xs%3Acode-blue?style=?style=plastic&logo=appveyor&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAAZQTFRF////////VXz1bAAAAAJ0Uk5T/wDltzBKAAAAlUlEQVR42uzXSwqAMAwE0Mn9L+3Ggtgkk35QwcnSJo9S+yGwM9DCooCbgn4YrJ4CIPUcQF7/XSBbx2TEz4sAZ2q1RAECBAiYBlCtvwN+KiYAlG7UDGj59MViT9hOwEqAhYCtAsUZvL6I6W8c2wcbd+LIWSCHSTeSAAECngN4xxIDSK9f4B9t377Wd7H5Nt7/Xz8eAgwAvesLRjYYPuUAAAAASUVORK5CYII=)](https://xscode.com/bytedeco/javacpp-presets) + + Introduction ------------ This directory contains the JavaCPP Presets module for: @@ -17,9 +21,7 @@ Java API documentation is available here: * http://bytedeco.org/javacpp-presets/bullet/apidocs/ -Special Mappings ----------------- - +### Special Mappings Mappings of `btAlignedObjectArray`'s instances for privitime types: | C++ | Java | @@ -37,5 +39,127 @@ the composite type, e.g. `btAlignedObjectArray` maps to Sample Usage ------------ +Here is a simple example of Bullet Physics SDK ported to Java and based on code found from: + + * https://github.com/bulletphysics/bullet3/tree/3.21/examples/ + +We can use [Maven 3](http://maven.apache.org/) to download and install automatically all the class files as well as the native binaries. To run this sample code, after creating the `pom.xml` and `SimpleBox.java` source files below, simply execute on the command line: +```bash + $ mvn compile exec:java +``` + +### The `pom.xml` build file +```xml + + 4.0.0 + org.bytedeco.bullet + samples + 1.5.8-SNAPSHOT + + SimpleBox + + + + org.bytedeco + bullet-platform + 3.21-1.5.8-SNAPSHOT + + + + . + + +``` + +### The `SimpleBox.java` source file +```java +import org.bytedeco.javacpp.*; +import org.bytedeco.bullet.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import org.bytedeco.bullet.LinearMath.*; + +public class SimpleBox { + + private static btDefaultCollisionConfiguration m_collisionConfiguration; + private static btCollisionDispatcher m_dispatcher; + private static btBroadphaseInterface m_broadphase; + private static btConstraintSolver m_solver; + private static btDiscreteDynamicsWorld m_dynamicsWorld; + + public static void main(String[] args) + { + createEmptyDynamicsWorld(); + + btBoxShape groundShape = new btBoxShape(new btVector3(50, 50, 50)); + + btTransform groundTransform = new btTransform(); + groundTransform.setIdentity(); + groundTransform.setOrigin(new btVector3(0, -50, 0)); + + createRigidBody(0, groundTransform, groundShape); + + btBoxShape colShape = new btBoxShape(new btVector3(1, 1, 1)); + float mass = 1.0f; + + colShape.calculateLocalInertia(mass, new btVector3(0, 0, 0)); + + btTransform startTransform = new btTransform(); + startTransform.setIdentity(); + startTransform.setOrigin(new btVector3(0, 3, 0)); + btRigidBody box = createRigidBody(mass, startTransform, colShape); + + for (int i = 0; i < 10; ++ i) + { + m_dynamicsWorld.stepSimulation(0.1f, 10, 0.01f); + btVector3 position = box.getWorldTransform().getOrigin(); + System.out.println(position.y()); + } + + System.out.println( + "\n" + + "This sample simulates falling of a rigid box, followed by \n" + + "an inelastic collision with a ground plane.\n" + + "The numbers show height of the box at each simulation step. \n" + + "It should start around 3.0 and end up around 1.0.\n"); + } + + private static void createEmptyDynamicsWorld() + { + m_collisionConfiguration = new btDefaultCollisionConfiguration(); + m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); + m_broadphase = new btDbvtBroadphase(); + m_solver = new btSequentialImpulseConstraintSolver(); + m_dynamicsWorld = new btDiscreteDynamicsWorld( + m_dispatcher, m_broadphase, m_solver, m_collisionConfiguration); + m_dynamicsWorld.setGravity(new btVector3(0, -10, 0)); + } + + private static btRigidBody createRigidBody( + float mass, + btTransform startTransform, + btCollisionShape shape) + { + boolean isDynamic = (mass != 0.f); + + btVector3 localInertia = new btVector3(0, 0, 0); + if (isDynamic) + shape.calculateLocalInertia(mass, localInertia); + + btDefaultMotionState motionState = new btDefaultMotionState( + startTransform, btTransform.getIdentity()); + + btRigidBody.btRigidBodyConstructionInfo cInfo = + new btRigidBody.btRigidBodyConstructionInfo( + mass, motionState, shape, localInertia); + + btRigidBody body = new btRigidBody(cInfo); + + body.setUserIndex(-1); + m_dynamicsWorld.addRigidBody(body); + + return body; + } +} +``` -See [samples](samples). +See the [samples](samples) subdirectory for more. diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh index 32406284db9..5f3396a4e37 100755 --- a/bullet/cppbuild.sh +++ b/bullet/cppbuild.sh @@ -1,9 +1,8 @@ #!/bin/bash - # This file is meant to be included by the parent cppbuild.sh script if [[ -z "$PLATFORM" ]]; then pushd .. - bash cppbuild.sh "$@" opencl + bash cppbuild.sh "$@" bullet popd exit fi @@ -14,13 +13,11 @@ download https://github.com/bulletphysics/bullet3/archive/refs/tags/$BULLET_VERS mkdir -p $PLATFORM cd $PLATFORM INSTALL_PATH=`pwd` - echo "Decompressing archives..." unzip -qo ../bullet-$BULLET_VERSION.zip - cd bullet3-$BULLET_VERSION -[ -d .build ] || mkdir .build -cd .build +mkdir -p build +cd build case $PLATFORM in android-arm) @@ -119,7 +116,53 @@ case $PLATFORM in make -j $MAKEJ make install/strip ;; + linux-x86) + export CC="gcc -m32" + export CXX="g++ -m32" + cmake \ + -DBUILD_BULLET2_DEMOS=OFF \ + -DBUILD_CLSOCKET=OFF \ + -DBUILD_CPU_DEMOS=OFF \ + -DBUILD_EGL=OFF \ + -DBUILD_ENET=OFF \ + -DBUILD_EXTRAS=OFF \ + -DBUILD_OPENGL3_DEMOS=OFF \ + -DBUILD_SHARED_LIBS=ON \ + -DBUILD_UNIT_TESTS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH \ + -DENABLE_VHACD=OFF \ + -DUSE_DOUBLE_PRECISION=OFF \ + -DUSE_GLUT=OFF \ + -DUSE_GRAPHICAL_BENCHMARK=OFF \ + .. + make -j $MAKEJ + make install/strip + ;; linux-x86_64) + export CC="gcc -m64" + export CXX="g++ -m64" + cmake \ + -DBUILD_BULLET2_DEMOS=OFF \ + -DBUILD_CLSOCKET=OFF \ + -DBUILD_CPU_DEMOS=OFF \ + -DBUILD_EGL=OFF \ + -DBUILD_ENET=OFF \ + -DBUILD_EXTRAS=OFF \ + -DBUILD_OPENGL3_DEMOS=OFF \ + -DBUILD_SHARED_LIBS=ON \ + -DBUILD_UNIT_TESTS=OFF \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=$INSTALL_PATH \ + -DENABLE_VHACD=OFF \ + -DUSE_DOUBLE_PRECISION=OFF \ + -DUSE_GLUT=OFF \ + -DUSE_GRAPHICAL_BENCHMARK=OFF \ + .. + make -j $MAKEJ + make install/strip + ;; + macosx-x86_64) cmake \ -DBUILD_BULLET2_DEMOS=OFF \ -DBUILD_CLSOCKET=OFF \ @@ -136,6 +179,7 @@ case $PLATFORM in -DUSE_DOUBLE_PRECISION=OFF \ -DUSE_GLUT=OFF \ -DUSE_GRAPHICAL_BENCHMARK=OFF \ + -DCMAKE_MACOSX_RPATH=ON \ .. make -j $MAKEJ make install/strip diff --git a/bullet/platform/pom.xml b/bullet/platform/pom.xml index c6a7cfae020..2c5cdfbcb30 100644 --- a/bullet/platform/pom.xml +++ b/bullet/platform/pom.xml @@ -54,12 +54,24 @@ ${project.version} ${javacpp.platform.android-x86_64} + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.linux-x86} + ${project.groupId} ${javacpp.moduleId} ${project.version} ${javacpp.platform.linux-x86_64} + + ${project.groupId} + ${javacpp.moduleId} + ${project.version} + ${javacpp.platform.macosx-x86_64} + ${project.groupId} ${javacpp.moduleId} @@ -84,16 +96,7 @@ - - ${javacpp.moduleId}.jar - ${javacpp.moduleId}-android-arm.jar - ${javacpp.moduleId}-android-arm64.jar - ${javacpp.moduleId}-android-x86.jar - ${javacpp.moduleId}-android-x86_64.jar - ${javacpp.moduleId}-linux-x86_64.jar - ${javacpp.moduleId}-windows-x86.jar - ${javacpp.moduleId}-windows-x86_64.jar - + ${javacpp.moduleId}.jar ${javacpp.moduleId}-linux-x86.jar ${javacpp.moduleId}-linux-x86_64.jar ${javacpp.moduleId}-macosx-x86_64.jar ${javacpp.moduleId}-windows-x86.jar ${javacpp.moduleId}-windows-x86_64.jar @@ -138,11 +141,13 @@ ${project.build.directory}/${project.artifactId}.jar module org.bytedeco.${javacpp.moduleId}.platform { - requires static org.bytedeco.${javacpp.moduleId}.android.arm; - requires static org.bytedeco.${javacpp.moduleId}.android.arm64; - requires static org.bytedeco.${javacpp.moduleId}.android.x86; - requires static org.bytedeco.${javacpp.moduleId}.android.x86_64; +// requires static org.bytedeco.${javacpp.moduleId}.android.arm; +// requires static org.bytedeco.${javacpp.moduleId}.android.arm64; +// requires static org.bytedeco.${javacpp.moduleId}.android.x86; +// requires static org.bytedeco.${javacpp.moduleId}.android.x86_64; + requires static org.bytedeco.${javacpp.moduleId}.linux.x86; requires static org.bytedeco.${javacpp.moduleId}.linux.x86_64; + requires static org.bytedeco.${javacpp.moduleId}.macosx.x86_64; requires static org.bytedeco.${javacpp.moduleId}.windows.x86; requires static org.bytedeco.${javacpp.moduleId}.windows.x86_64; } @@ -155,4 +160,5 @@ + diff --git a/bullet/samples/pom.xml b/bullet/samples/pom.xml index 5a5f9108053..1b70287993a 100644 --- a/bullet/samples/pom.xml +++ b/bullet/samples/pom.xml @@ -4,6 +4,7 @@ samples 1.5.8-SNAPSHOT + SimpleBox 1.7 1.7 diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 80d05a3b667..07722c0055f 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -1,3 +1,25 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.bytedeco.bullet.presets; import org.bytedeco.javacpp.Loader; @@ -8,6 +30,10 @@ import org.bytedeco.javacpp.tools.InfoMap; import org.bytedeco.javacpp.tools.InfoMapper; +/** + * + * @author Andrey Krainyak + */ @Properties( inherit = LinearMath.class, value = { @@ -73,7 +99,7 @@ "BulletCollision/CollisionShapes/btMultiSphereShape.h", "BulletCollision/CollisionShapes/btUniformScalingShape.h", }, - link = "BulletCollision" + link = "BulletCollision@.3.20" ) }, target = "org.bytedeco.bullet.BulletCollision", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index cfae84186e5..33889601265 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -1,3 +1,25 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.bytedeco.bullet.presets; import org.bytedeco.javacpp.Loader; @@ -8,6 +30,10 @@ import org.bytedeco.javacpp.tools.InfoMap; import org.bytedeco.javacpp.tools.InfoMapper; +/** + * + * @author Andrey Krainyak + */ @Properties( inherit = BulletCollision.class, value = { @@ -51,7 +77,7 @@ "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h", "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h", }, - link = "BulletDynamics" + link = "BulletDynamics@.3.20" ) }, target = "org.bytedeco.bullet.BulletDynamics", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index e17397b3f56..982b018ec7b 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -1,3 +1,25 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.bytedeco.bullet.presets; import org.bytedeco.javacpp.Loader; @@ -11,6 +33,10 @@ import org.bytedeco.javacpp.FunctionPointer; import org.bytedeco.javacpp.Pointer; +/** + * + * @author Andrey Krainyak + */ @Properties( inherit = BulletDynamics.class, value = { @@ -31,7 +57,7 @@ "BulletSoftBody/btDeformableBackwardEulerObjective.h", "BulletSoftBody/btDeformableLagrangianForce.h", }, - link = "BulletSoftBody" + link = "BulletSoftBody@.3.20" ) }, target = "org.bytedeco.bullet.BulletSoftBody", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 71dc62eacf2..46e896bb9fb 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -1,3 +1,25 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.bytedeco.bullet.presets; import org.bytedeco.javacpp.Loader; @@ -8,6 +30,10 @@ import org.bytedeco.javacpp.tools.InfoMap; import org.bytedeco.javacpp.tools.InfoMapper; +/** + * + * @author Andrey Krainyak + */ @Properties( inherit = javacpp.class, value = { @@ -30,7 +56,7 @@ "LinearMath/btPoolAllocator.h", "LinearMath/btStackAlloc.h", }, - link = "LinearMath" + link = "LinearMath@.3.20" ) }, target = "org.bytedeco.bullet.LinearMath", diff --git a/cppbuild.sh b/cppbuild.sh index 317085d4b67..1846f54e733 100755 --- a/cppbuild.sh +++ b/cppbuild.sh @@ -158,7 +158,7 @@ function sedinplace { } if [[ -z ${PROJECTS:-} ]]; then - PROJECTS=(opencv ffmpeg flycapture spinnaker libdc1394 libfreenect libfreenect2 librealsense librealsense2 videoinput artoolkitplus chilitags flandmark arrow hdf5 hyperscan lz4 mkl mkl-dnn dnnl openblas arpack-ng cminpack fftw gsl cpython numpy scipy gym llvm libpostal leptonica tesseract caffe openpose cuda nvcodec opencl mxnet pytorch tensorflow tensorflow-lite tensorrt tritonserver depthai ale onnx ngraph onnxruntime tvm liquidfun qt skia cpu_features modsecurity systems) + PROJECTS=(opencv ffmpeg flycapture spinnaker libdc1394 libfreenect libfreenect2 librealsense librealsense2 videoinput artoolkitplus chilitags flandmark arrow hdf5 hyperscan lz4 mkl mkl-dnn dnnl openblas arpack-ng cminpack fftw gsl cpython numpy scipy gym llvm libpostal leptonica tesseract caffe openpose cuda nvcodec opencl mxnet pytorch tensorflow tensorflow-lite tensorrt tritonserver depthai ale onnx ngraph onnxruntime tvm bullet liquidfun qt skia cpu_features modsecurity systems) fi for PROJECT in ${PROJECTS[@]}; do diff --git a/platform/pom.xml b/platform/pom.xml index f7d4b0f463b..8f019f8c5fe 100644 --- a/platform/pom.xml +++ b/platform/pom.xml @@ -66,13 +66,13 @@ ../ngraph/platform ../onnxruntime/platform ../tvm/platform + ../bullet/platform ../liquidfun/platform ../qt/platform ../skia/platform ../cpu_features/platform ../modsecurity/platform ../systems/platform - ../bullet/platform @@ -337,6 +337,11 @@ tvm-platform 0.8.0-${project.version} + + org.bytedeco + bullet-platform + 3.21-${project.version} + org.bytedeco liquidfun-platform @@ -367,11 +372,6 @@ systems-platform ${project.version} - - org.bytedeco - bullet-platform - 3.21-${project.version} - diff --git a/pom.xml b/pom.xml index 1b4902c6b6c..017f8ce516e 100644 --- a/pom.xml +++ b/pom.xml @@ -628,13 +628,13 @@ ngraph onnxruntime tvm + bullet liquidfun qt skia cpu_features modsecurity systems - bullet ${os.name}-${os.arch} @@ -778,8 +778,8 @@ leptonica tesseract tensorflow - cpu_features bullet + cpu_features ${javacpp.platform.library.path} @@ -828,8 +828,8 @@ leptonica tesseract tensorflow - cpu_features bullet + cpu_features ${javacpp.platform.library.path} @@ -878,8 +878,8 @@ leptonica tesseract tensorflow - cpu_features bullet + cpu_features ${javacpp.platform.library.path} @@ -928,8 +928,8 @@ leptonica tesseract tensorflow - cpu_features bullet + cpu_features ${javacpp.platform.library.path} @@ -1317,6 +1317,7 @@ tensorflow ale depthai + bullet liquidfun skia cpu_features @@ -1402,13 +1403,13 @@ ngraph onnxruntime tvm + bullet liquidfun qt skia cpu_features modsecurity systems - bullet @@ -1520,6 +1521,7 @@ ngraph onnxruntime tvm + bullet liquidfun qt skia @@ -1587,10 +1589,10 @@ leptonica tesseract ale + bullet liquidfun cpu_features systems - bullet @@ -1668,11 +1670,11 @@ onnx onnxruntime tvm + bullet liquidfun qt cpu_features systems - bullet From af6f9b908bedbb5eff81599a2e9cc5df0632fa32 Mon Sep 17 00:00:00 2001 From: Samuel Audet Date: Mon, 28 Feb 2022 12:35:14 +0900 Subject: [PATCH 39/81] Fix builds on Mac --- bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java | 2 +- .../src/main/java/org/bytedeco/bullet/presets/LinearMath.java | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index ec4712bc41f..268a35af759 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -133,7 +133,7 @@ public class LinearMath extends org.bytedeco.bullet.presets.LinearMath { // #ifndef BT_INFINITY // #define BT_INFINITY (btInfinityMask.mask) - public static native int btGetInfinityMask(); + // #endif // #endif //BT_USE_NEON diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 46e896bb9fb..6735591754a 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -117,6 +117,7 @@ public void map(InfoMap infoMap) { "SIMD_INFINITY", "btAlignedObjectArray::findBinarySearch", "btBulletSerializedArrays", + "btGetInfinityMask", "btInfMaskConverter" ).skip()) ; From 9df76aa0f17f8a4d77f874468171b81a4a6406da Mon Sep 17 00:00:00 2001 From: Samuel Audet Date: Mon, 28 Feb 2022 14:04:41 +0900 Subject: [PATCH 40/81] Update URL in README.md --- bullet/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bullet/README.md b/bullet/README.md index 69f6a9a80e7..275ada803c4 100644 --- a/bullet/README.md +++ b/bullet/README.md @@ -9,7 +9,7 @@ Introduction ------------ This directory contains the JavaCPP Presets module for: - * Bullet Physics SDK 3.21 https://pybullet.org/wordpress + * Bullet Physics SDK 3.21 https://github.com/bulletphysics/bullet3 Please refer to the parent README.md file for more detailed information about the JavaCPP Presets. From c81c37798a0933cbc453427c332a08801e39ed4a Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 28 Feb 2022 18:19:47 +0800 Subject: [PATCH 41/81] Map extra headers from bullet's LinearMath Referenced from bullet's examples. --- bullet/README.md | 13 +++++---- .../bytedeco/bullet/presets/LinearMath.java | 29 +++++++++++++++++++ 2 files changed, 36 insertions(+), 6 deletions(-) diff --git a/bullet/README.md b/bullet/README.md index 275ada803c4..c8d0e453c59 100644 --- a/bullet/README.md +++ b/bullet/README.md @@ -24,12 +24,13 @@ Java API documentation is available here: ### Special Mappings Mappings of `btAlignedObjectArray`'s instances for privitime types: -| C++ | Java | -|----------------------------------|-----------------| -| `btAlignedObjectArray` | `btBoolArray` | -| `btAlignedObjectArray` | `btCharArray` | -| `btAlignedObjectArray` | `btIntArray` | -| `btAlignedObjectArray` | `btScalarArray` | +| C++ | Java | +|--------------------------------------|-----------------| +| `btAlignedObjectArray` | `btBoolArray` | +| `btAlignedObjectArray` | `btCharArray` | +| `btAlignedObjectArray` | `btIntArray` | +| `btAlignedObjectArray` | `btUIntArray` | +| `btAlignedObjectArray` | `btScalarArray` | Name of a Java class, corresponding to an instance of `btAlignedObjectArray` for a composite type, is constructed by adding `Array` suffix to the name of diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 6735591754a..df702a28d27 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -55,6 +55,14 @@ "LinearMath/btSpatialAlgebra.h", "LinearMath/btPoolAllocator.h", "LinearMath/btStackAlloc.h", + "LinearMath/TaskScheduler/btThreadSupportInterface.h", + "LinearMath/btThreads.h", + "LinearMath/btAlignedAllocator.h", + "LinearMath/btConvexHull.h", + "LinearMath/btConvexHullComputer.h", + "LinearMath/btGeometryUtil.h", + "LinearMath/btMinMax.h", + "LinearMath/btTransformUtil.h", }, link = "LinearMath@.3.20" ) @@ -68,6 +76,7 @@ public class LinearMath implements InfoMapper { public void map(InfoMap infoMap) { infoMap .put(new Info("ATTRIBUTE_ALIGNED16").cppText("#define ATTRIBUTE_ALIGNED16(x) x")) + .put(new Info("BT_OVERRIDE").cppText("#define BT_OVERRIDE")) .put(new Info("btMatrix3x3Data").cppText("#define btMatrix3x3Data btMatrix3x3FloatData")) .put(new Info("btQuaternionData").cppText("#define btQuaternionData btQuaternionFloatData")) .put(new Info("btTransformData").cppText("#define btTransformData btTransformFloatData")) @@ -78,6 +87,7 @@ public void map(InfoMap infoMap) { .put(new Info( "(defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION)))", "(defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)", + "BT_DEBUG_MEMORY_ALLOCATIONS", "BT_USE_DOUBLE_PRECISION", "BT_USE_NEON", "BT_USE_SSE", @@ -100,12 +110,19 @@ public void map(InfoMap infoMap) { .put(new Info("btAlignedObjectArray").pointerTypes("btBoolArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btCharArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btIntArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btUIntArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btScalarArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btMatrix3x3Array")) .put(new Info("btAlignedObjectArray").pointerTypes("btQuaternionArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btVector3Array")) .put(new Info("btAlignedObjectArray").pointerTypes("btVector4Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("btPlaneArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btConvexHHalfEdgeArray")) + .put(new Info("ConvexH::HalfEdge").pointerTypes("ConvexH.HalfEdge")) + .put(new Info("btAlignedObjectArray").pointerTypes("btConvexHullComputerEdgeArray")) + .put(new Info("btConvexHullComputer::Edge").pointerTypes("btConvexHullComputer.Edge")) .put(new Info("btHashMap").pointerTypes("btHashMap_btHashPtr_voidPointer")) + .put(new Info("int4").pointerTypes("Int4")) .put(new Info("btAlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) @@ -115,7 +132,19 @@ public void map(InfoMap infoMap) { "BT_NAN", "SIMD_EPSILON", "SIMD_INFINITY", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btBulletSerializedArrays", "btGetInfinityMask", "btInfMaskConverter" From bca797b52d3fc864a12e61ee38b07859a88a6abb Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 28 Feb 2022 18:23:05 +0800 Subject: [PATCH 42/81] Update generated code of bullet preset See parent commit. --- .../bytedeco/bullet/LinearMath/ConvexH.java | 58 +++ .../bytedeco/bullet/LinearMath/HullDesc.java | 60 +++ .../bullet/LinearMath/HullLibrary.java | 39 ++ .../bullet/LinearMath/HullResult.java | 40 ++ .../org/bytedeco/bullet/LinearMath/Int4.java | 38 ++ .../bullet/LinearMath/PHullResult.java | 37 ++ .../bullet/LinearMath/btAlignedAllocFunc.java | 22 + .../bullet/LinearMath/btAlignedFreeFunc.java | 21 + .../bullet/LinearMath/btAllocFunc.java | 21 + .../LinearMath/btConvexHHalfEdgeArray.java | 86 ++++ .../LinearMath/btConvexHullComputer.java | 95 +++++ .../btConvexHullComputerEdgeArray.java | 86 ++++ .../btConvexSeparatingDistanceUtil.java | 30 ++ .../bullet/LinearMath/btCriticalSection.java | 23 ++ .../bullet/LinearMath/btFreeFunc.java | 21 + .../bullet/LinearMath/btGeometryUtil.java | 42 ++ .../bullet/LinearMath/btIParallelForBody.java | 24 ++ .../bullet/LinearMath/btIParallelSumBody.java | 25 ++ .../bullet/LinearMath/btITaskScheduler.java | 36 ++ .../bytedeco/bullet/LinearMath/btPlane.java | 35 ++ .../bullet/LinearMath/btPlaneArray.java | 86 ++++ .../bullet/LinearMath/btSpinMutex.java | 40 ++ .../LinearMath/btThreadSupportInterface.java | 71 ++++ .../bullet/LinearMath/btTransformUtil.java | 46 +++ .../bullet/LinearMath/btUIntArray.java | 86 ++++ .../bytedeco/bullet/global/LinearMath.java | 385 ++++++++++++++++++ 26 files changed, 1553 insertions(+) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/ConvexH.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullDesc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullLibrary.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullResult.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/Int4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/PHullResult.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedAllocFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedFreeFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAllocFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHHalfEdgeArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHullComputer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHullComputerEdgeArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexSeparatingDistanceUtil.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btCriticalSection.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btFreeFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btGeometryUtil.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIParallelForBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIParallelSumBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btITaskScheduler.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPlane.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPlaneArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpinMutex.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btThreadSupportInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformUtil.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btUIntArray.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/ConvexH.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/ConvexH.java new file mode 100644 index 00000000000..c4b03e8c740 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/ConvexH.java @@ -0,0 +1,58 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class ConvexH extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ConvexH(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public ConvexH(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public ConvexH position(long position) { + return (ConvexH)super.position(position); + } + @Override public ConvexH getPointer(long i) { + return new ConvexH((Pointer)this).offsetAddress(i); + } + + @NoOffset public static class HalfEdge extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public HalfEdge(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public HalfEdge(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public HalfEdge position(long position) { + return (HalfEdge)super.position(position); + } + @Override public HalfEdge getPointer(long i) { + return new HalfEdge((Pointer)this).offsetAddress(i); + } + + public native short ea(); public native HalfEdge ea(short setter); // the other half of the edge (index into edges list) + public native @Cast("unsigned char") byte v(); public native HalfEdge v(byte setter); // the vertex at the start of this edge (index into vertices list) + public native @Cast("unsigned char") byte p(); public native HalfEdge p(byte setter); // the facet on which this edge lies (index into facets list) + public HalfEdge() { super((Pointer)null); allocate(); } + private native void allocate(); + public HalfEdge(short _ea, @Cast("unsigned char") byte _v, @Cast("unsigned char") byte _p) { super((Pointer)null); allocate(_ea, _v, _p); } + private native void allocate(short _ea, @Cast("unsigned char") byte _v, @Cast("unsigned char") byte _p); + } + public ConvexH() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @ByRef btVector3Array vertices(); public native ConvexH vertices(btVector3Array setter); + public native @ByRef btConvexHHalfEdgeArray edges(); public native ConvexH edges(btConvexHHalfEdgeArray setter); + public native @ByRef btPlaneArray facets(); public native ConvexH facets(btPlaneArray setter); + public ConvexH(int vertices_size, int edges_size, int facets_size) { super((Pointer)null); allocate(vertices_size, edges_size, facets_size); } + private native void allocate(int vertices_size, int edges_size, int facets_size); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullDesc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullDesc.java new file mode 100644 index 00000000000..c5cd2661d07 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullDesc.java @@ -0,0 +1,60 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class HullDesc extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public HullDesc(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public HullDesc(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public HullDesc position(long position) { + return (HullDesc)super.position(position); + } + @Override public HullDesc getPointer(long i) { + return new HullDesc((Pointer)this).offsetAddress(i); + } + + public HullDesc() { super((Pointer)null); allocate(); } + private native void allocate(); + + public HullDesc(@Cast("HullFlag") int flag, + @Cast("unsigned int") int vcount, + @Const btVector3 vertices, + @Cast("unsigned int") int stride/*=sizeof(btVector3)*/) { super((Pointer)null); allocate(flag, vcount, vertices, stride); } + private native void allocate(@Cast("HullFlag") int flag, + @Cast("unsigned int") int vcount, + @Const btVector3 vertices, + @Cast("unsigned int") int stride/*=sizeof(btVector3)*/); + public HullDesc(@Cast("HullFlag") int flag, + @Cast("unsigned int") int vcount, + @Const btVector3 vertices) { super((Pointer)null); allocate(flag, vcount, vertices); } + private native void allocate(@Cast("HullFlag") int flag, + @Cast("unsigned int") int vcount, + @Const btVector3 vertices); + + public native @Cast("bool") boolean HasHullFlag(@Cast("HullFlag") int flag); + + public native void SetHullFlag(@Cast("HullFlag") int flag); + + public native void ClearHullFlag(@Cast("HullFlag") int flag); + + public native @Cast("unsigned int") int mFlags(); public native HullDesc mFlags(int setter); // flags to use when generating the convex hull. + public native @Cast("unsigned int") int mVcount(); public native HullDesc mVcount(int setter); // number of vertices in the input point cloud + public native @Const btVector3 mVertices(); public native HullDesc mVertices(btVector3 setter); // the array of vertices. + public native @Cast("unsigned int") int mVertexStride(); public native HullDesc mVertexStride(int setter); // the stride of each vertex, in bytes. + public native @Cast("btScalar") float mNormalEpsilon(); public native HullDesc mNormalEpsilon(float setter); // the epsilon for removing duplicates. This is a normalized value, if normalized bit is on. + public native @Cast("unsigned int") int mMaxVertices(); public native HullDesc mMaxVertices(int setter); // maximum number of vertices to be considered for the hull! + public native @Cast("unsigned int") int mMaxFaces(); public native HullDesc mMaxFaces(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullLibrary.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullLibrary.java new file mode 100644 index 00000000000..aa6c88e0fad --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullLibrary.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The HullLibrary class can create a convex hull from a collection of vertices, using the ComputeHull method. + * The btShapeHull class uses this HullLibrary to create a approximate convex mesh given a general (non-polyhedral) convex shape. */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class HullLibrary extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public HullLibrary() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public HullLibrary(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public HullLibrary(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public HullLibrary position(long position) { + return (HullLibrary)super.position(position); + } + @Override public HullLibrary getPointer(long i) { + return new HullLibrary((Pointer)this).offsetAddress(i); + } + + public native @ByRef btIntArray m_vertexIndexMapping(); public native HullLibrary m_vertexIndexMapping(btIntArray setter); + + public native @Cast("HullError") int CreateConvexHull(@Const @ByRef HullDesc desc, + @ByRef HullResult result); // contains the resulst + public native @Cast("HullError") int ReleaseResult(@ByRef HullResult result); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullResult.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullResult.java new file mode 100644 index 00000000000..85a43bf9720 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/HullResult.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class HullResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public HullResult(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public HullResult(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public HullResult position(long position) { + return (HullResult)super.position(position); + } + @Override public HullResult getPointer(long i) { + return new HullResult((Pointer)this).offsetAddress(i); + } + + public HullResult() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("bool") boolean mPolygons(); public native HullResult mPolygons(boolean setter); // true if indices represents polygons, false indices are triangles + public native @Cast("unsigned int") int mNumOutputVertices(); public native HullResult mNumOutputVertices(int setter); // number of vertices in the output hull + public native @ByRef btVector3Array m_OutputVertices(); public native HullResult m_OutputVertices(btVector3Array setter); // array of vertices + public native @Cast("unsigned int") int mNumFaces(); public native HullResult mNumFaces(int setter); // the number of faces produced + public native @Cast("unsigned int") int mNumIndices(); public native HullResult mNumIndices(int setter); // the total number of indices + public native @ByRef btUIntArray m_Indices(); public native HullResult m_Indices(btUIntArray setter); // pointer to indices. + + // If triangles, then indices are array indexes into the vertex list. + // If polygons, indices are in the form (number of points in face) (p1, p2, p3, ..) etc.. +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/Int4.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/Int4.java new file mode 100644 index 00000000000..2ee7ec67439 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/Int4.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Name("int4") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class Int4 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Int4(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Int4(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Int4 position(long position) { + return (Int4)super.position(position); + } + @Override public Int4 getPointer(long i) { + return new Int4((Pointer)this).offsetAddress(i); + } + + public native int x(); public native Int4 x(int setter); + public native int y(); public native Int4 y(int setter); + public native int z(); public native Int4 z(int setter); + public native int w(); public native Int4 w(int setter); + public Int4() { super((Pointer)null); allocate(); } + private native void allocate(); + public Int4(int _x, int _y, int _z, int _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(int _x, int _y, int _z, int _w); + public native @ByRef @Name("operator []") IntPointer get(int i); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/PHullResult.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/PHullResult.java new file mode 100644 index 00000000000..c9d246b0b32 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/PHullResult.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class PHullResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public PHullResult(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public PHullResult(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public PHullResult position(long position) { + return (PHullResult)super.position(position); + } + @Override public PHullResult getPointer(long i) { + return new PHullResult((Pointer)this).offsetAddress(i); + } + + public PHullResult() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("unsigned int") int mVcount(); public native PHullResult mVcount(int setter); + public native @Cast("unsigned int") int mIndexCount(); public native PHullResult mIndexCount(int setter); + public native @Cast("unsigned int") int mFaceCount(); public native PHullResult mFaceCount(int setter); + public native btVector3 mVertices(); public native PHullResult mVertices(btVector3 setter); + public native @ByRef @Cast("TUIntArray*") btUIntArray m_Indices(); public native PHullResult m_Indices(btUIntArray setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedAllocFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedAllocFunc.java new file mode 100644 index 00000000000..22658ba8dcc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedAllocFunc.java @@ -0,0 +1,22 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedAllocFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedAllocFunc(Pointer p) { super(p); } + protected btAlignedAllocFunc() { allocate(); } + private native void allocate(); + public native Pointer call(@Cast("size_t") long size, int alignment); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedFreeFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedFreeFunc.java new file mode 100644 index 00000000000..1aec3d40e3f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAlignedFreeFunc.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAlignedFreeFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedFreeFunc(Pointer p) { super(p); } + protected btAlignedFreeFunc() { allocate(); } + private native void allocate(); + public native void call(Pointer memblock); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAllocFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAllocFunc.java new file mode 100644 index 00000000000..aef49d4f73d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btAllocFunc.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btAllocFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAllocFunc(Pointer p) { super(p); } + protected btAllocFunc() { allocate(); } + private native void allocate(); + public native Pointer call(@Cast("size_t") long size); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHHalfEdgeArray.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHHalfEdgeArray.java new file mode 100644 index 00000000000..56fdd771fa8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHHalfEdgeArray.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btConvexHHalfEdgeArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexHHalfEdgeArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexHHalfEdgeArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btConvexHHalfEdgeArray position(long position) { + return (btConvexHHalfEdgeArray)super.position(position); + } + @Override public btConvexHHalfEdgeArray getPointer(long i) { + return new btConvexHHalfEdgeArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btConvexHHalfEdgeArray put(@Const @ByRef btConvexHHalfEdgeArray other); + public btConvexHHalfEdgeArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btConvexHHalfEdgeArray(@Const @ByRef btConvexHHalfEdgeArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btConvexHHalfEdgeArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef ConvexH.HalfEdge at(int n); + + public native @ByRef @Name("operator []") ConvexH.HalfEdge get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "ConvexH::HalfEdge()") ConvexH.HalfEdge fillData); + public native void resize(int newsize); + public native @ByRef ConvexH.HalfEdge expandNonInitializing(); + + public native @ByRef ConvexH.HalfEdge expand(@Const @ByRef(nullValue = "ConvexH::HalfEdge()") ConvexH.HalfEdge fillValue); + public native @ByRef ConvexH.HalfEdge expand(); + + public native void push_back(@Const @ByRef ConvexH.HalfEdge _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btConvexHHalfEdgeArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHullComputer.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHullComputer.java new file mode 100644 index 00000000000..95ff52e251a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHullComputer.java @@ -0,0 +1,95 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/** Convex hull implementation based on Preparata and Hong + * See http://code.google.com/p/bullet/issues/detail?id=275 + * Ole Kniemeyer, MAXON Computer GmbH */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btConvexHullComputer extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btConvexHullComputer() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexHullComputer(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexHullComputer(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btConvexHullComputer position(long position) { + return (btConvexHullComputer)super.position(position); + } + @Override public btConvexHullComputer getPointer(long i) { + return new btConvexHullComputer((Pointer)this).offsetAddress(i); + } + + public static class Edge extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public Edge() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Edge(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Edge(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Edge position(long position) { + return (Edge)super.position(position); + } + @Override public Edge getPointer(long i) { + return new Edge((Pointer)this).offsetAddress(i); + } + + public native int getSourceVertex(); + + public native int getTargetVertex(); + + public native @Const Edge getNextEdgeOfVertex(); + + public native @Const Edge getNextEdgeOfFace(); + + public native @Const Edge getReverseEdge(); + } + + // Vertices of the output hull + public native @ByRef btVector3Array vertices(); public native btConvexHullComputer vertices(btVector3Array setter); + + // The original vertex index in the input coords array + public native @ByRef btIntArray original_vertex_index(); public native btConvexHullComputer original_vertex_index(btIntArray setter); + + // Edges of the output hull + public native @ByRef btConvexHullComputerEdgeArray edges(); public native btConvexHullComputer edges(btConvexHullComputerEdgeArray setter); + + // Faces of the convex hull. Each entry is an index into the "edges" array pointing to an edge of the face. Faces are planar n-gons + public native @ByRef btIntArray faces(); public native btConvexHullComputer faces(btIntArray setter); + + /* + Compute convex hull of "count" vertices stored in "coords". "stride" is the difference in bytes + between the addresses of consecutive vertices. If "shrink" is positive, the convex hull is shrunken + by that amount (each face is moved by "shrink" length units towards the center along its normal). + If "shrinkClamp" is positive, "shrink" is clamped to not exceed "shrinkClamp * innerRadius", where "innerRadius" + is the minimum distance of a face to the center of the convex hull. + + The returned value is the amount by which the hull has been shrunken. If it is negative, the amount was so large + that the resulting convex hull is empty. + + The output convex hull can be found in the member variables "vertices", "edges", "faces". + */ + public native @Cast("btScalar") float compute(@Const FloatPointer coords, int stride, int count, @Cast("btScalar") float shrink, @Cast("btScalar") float shrinkClamp); + public native @Cast("btScalar") float compute(@Const FloatBuffer coords, int stride, int count, @Cast("btScalar") float shrink, @Cast("btScalar") float shrinkClamp); + public native @Cast("btScalar") float compute(@Const float[] coords, int stride, int count, @Cast("btScalar") float shrink, @Cast("btScalar") float shrinkClamp); + + // same as above, but double precision + public native @Cast("btScalar") float compute(@Const DoublePointer coords, int stride, int count, @Cast("btScalar") float shrink, @Cast("btScalar") float shrinkClamp); + public native @Cast("btScalar") float compute(@Const DoubleBuffer coords, int stride, int count, @Cast("btScalar") float shrink, @Cast("btScalar") float shrinkClamp); + public native @Cast("btScalar") float compute(@Const double[] coords, int stride, int count, @Cast("btScalar") float shrink, @Cast("btScalar") float shrinkClamp); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHullComputerEdgeArray.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHullComputerEdgeArray.java new file mode 100644 index 00000000000..efc203bea97 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexHullComputerEdgeArray.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btConvexHullComputerEdgeArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexHullComputerEdgeArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexHullComputerEdgeArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btConvexHullComputerEdgeArray position(long position) { + return (btConvexHullComputerEdgeArray)super.position(position); + } + @Override public btConvexHullComputerEdgeArray getPointer(long i) { + return new btConvexHullComputerEdgeArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btConvexHullComputerEdgeArray put(@Const @ByRef btConvexHullComputerEdgeArray other); + public btConvexHullComputerEdgeArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btConvexHullComputerEdgeArray(@Const @ByRef btConvexHullComputerEdgeArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btConvexHullComputerEdgeArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btConvexHullComputer.Edge at(int n); + + public native @ByRef @Name("operator []") btConvexHullComputer.Edge get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btConvexHullComputer::Edge()") btConvexHullComputer.Edge fillData); + public native void resize(int newsize); + public native @ByRef btConvexHullComputer.Edge expandNonInitializing(); + + public native @ByRef btConvexHullComputer.Edge expand(@Const @ByRef(nullValue = "btConvexHullComputer::Edge()") btConvexHullComputer.Edge fillValue); + public native @ByRef btConvexHullComputer.Edge expand(); + + public native void push_back(@Const @ByRef btConvexHullComputer.Edge _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btConvexHullComputerEdgeArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexSeparatingDistanceUtil.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexSeparatingDistanceUtil.java new file mode 100644 index 00000000000..9322ee81e05 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btConvexSeparatingDistanceUtil.java @@ -0,0 +1,30 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btConvexSeparatingDistanceUtil can help speed up convex collision detection + * by conservatively updating a cached separating distance/vector instead of re-calculating the closest distance */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btConvexSeparatingDistanceUtil extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexSeparatingDistanceUtil(Pointer p) { super(p); } + + public btConvexSeparatingDistanceUtil(@Cast("btScalar") float boundingRadiusA, @Cast("btScalar") float boundingRadiusB) { super((Pointer)null); allocate(boundingRadiusA, boundingRadiusB); } + private native void allocate(@Cast("btScalar") float boundingRadiusA, @Cast("btScalar") float boundingRadiusB); + + public native @Cast("btScalar") float getConservativeSeparatingDistance(); + + public native void updateSeparatingDistance(@Const @ByRef btTransform transA, @Const @ByRef btTransform transB); + + public native void initSeparatingDistance(@Const @ByRef btVector3 separatingVector, @Cast("btScalar") float separatingDistance, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btCriticalSection.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btCriticalSection.java new file mode 100644 index 00000000000..0a618c4e20f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btCriticalSection.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btCriticalSection extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCriticalSection(Pointer p) { super(p); } + + + public native void lock(); + public native void unlock(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btFreeFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btFreeFunc.java new file mode 100644 index 00000000000..f4a1fd33f95 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btFreeFunc.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btFreeFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btFreeFunc(Pointer p) { super(p); } + protected btFreeFunc() { allocate(); } + private native void allocate(); + public native void call(Pointer memblock); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btGeometryUtil.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btGeometryUtil.java new file mode 100644 index 00000000000..2ad5e1136e1 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btGeometryUtil.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/**The btGeometryUtil helper class provides a few methods to convert between plane equations and vertices. */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btGeometryUtil extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGeometryUtil() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGeometryUtil(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeometryUtil(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGeometryUtil position(long position) { + return (btGeometryUtil)super.position(position); + } + @Override public btGeometryUtil getPointer(long i) { + return new btGeometryUtil((Pointer)this).offsetAddress(i); + } + + public static native void getPlaneEquationsFromVertices(@ByRef btVector3Array vertices, @ByRef btVector3Array planeEquationsOut); + + public static native void getVerticesFromPlaneEquations(@Const @ByRef btVector3Array planeEquations, @ByRef btVector3Array verticesOut); + + public static native @Cast("bool") boolean isInside(@Const @ByRef btVector3Array vertices, @Const @ByRef btVector3 planeNormal, @Cast("btScalar") float margin); + + public static native @Cast("bool") boolean isPointInsidePlanes(@Const @ByRef btVector3Array planeEquations, @Const @ByRef btVector3 point, @Cast("btScalar") float margin); + + public static native @Cast("bool") boolean areVerticesBehindPlane(@Const @ByRef btVector3 planeNormal, @Const @ByRef btVector3Array vertices, @Cast("btScalar") float margin); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIParallelForBody.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIParallelForBody.java new file mode 100644 index 00000000000..409d2fc692a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIParallelForBody.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +// +// btIParallelForBody -- subclass this to express work that can be done in parallel +// +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btIParallelForBody extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIParallelForBody(Pointer p) { super(p); } + + public native void forLoop(int iBegin, int iEnd); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIParallelSumBody.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIParallelSumBody.java new file mode 100644 index 00000000000..8e9c424459e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIParallelSumBody.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +// +// btIParallelSumBody -- subclass this to express work that can be done in parallel +// and produces a sum over all loop elements +// +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btIParallelSumBody extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIParallelSumBody(Pointer p) { super(p); } + + public native @Cast("btScalar") float sumLoop(int iBegin, int iEnd); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btITaskScheduler.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btITaskScheduler.java new file mode 100644 index 00000000000..537052cf20b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btITaskScheduler.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +// +// btITaskScheduler -- subclass this to implement a task scheduler that can dispatch work to +// worker threads +// +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btITaskScheduler extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btITaskScheduler(Pointer p) { super(p); } + + public native @Cast("const char*") BytePointer getName(); + + public native int getMaxNumThreads(); + public native int getNumThreads(); + public native void setNumThreads(int numThreads); + public native void parallelFor(int iBegin, int iEnd, int grainSize, @Const @ByRef btIParallelForBody body); + public native @Cast("btScalar") float parallelSum(int iBegin, int iEnd, int grainSize, @Const @ByRef btIParallelSumBody body); + public native void sleepWorkerThreadsHint(); // hint the task scheduler that we may not be using these threads for a little while + + // internal use only + public native void activate(); + public native void deactivate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPlane.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPlane.java new file mode 100644 index 00000000000..814b4648b23 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPlane.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btPlane extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPlane(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPlane(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btPlane position(long position) { + return (btPlane)super.position(position); + } + @Override public btPlane getPointer(long i) { + return new btPlane((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 normal(); public native btPlane normal(btVector3 setter); + public native @Cast("btScalar") float dist(); public native btPlane dist(float setter); // distance below origin - the D from plane equasion Ax+By+Cz+D=0 + public btPlane(@Const @ByRef btVector3 n, @Cast("btScalar") float d) { super((Pointer)null); allocate(n, d); } + private native void allocate(@Const @ByRef btVector3 n, @Cast("btScalar") float d); + public btPlane() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPlaneArray.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPlaneArray.java new file mode 100644 index 00000000000..fed38d52b85 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btPlaneArray.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btPlaneArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPlaneArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPlaneArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btPlaneArray position(long position) { + return (btPlaneArray)super.position(position); + } + @Override public btPlaneArray getPointer(long i) { + return new btPlaneArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btPlaneArray put(@Const @ByRef btPlaneArray other); + public btPlaneArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btPlaneArray(@Const @ByRef btPlaneArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btPlaneArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btPlane at(int n); + + public native @ByRef @Name("operator []") btPlane get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btPlane()") btPlane fillData); + public native void resize(int newsize); + public native @ByRef btPlane expandNonInitializing(); + + public native @ByRef btPlane expand(@Const @ByRef(nullValue = "btPlane()") btPlane fillValue); + public native @ByRef btPlane expand(); + + public native void push_back(@Const @ByRef btPlane _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btPlaneArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpinMutex.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpinMutex.java new file mode 100644 index 00000000000..878471e2097 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btSpinMutex.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + // notify that all worker threads have been destroyed + +/** + * btSpinMutex -- lightweight spin-mutex implemented with atomic ops, never puts + * a thread to sleep because it is designed to be used with a task scheduler + * which has one thread per core and the threads don't sleep until they + * run out of tasks. Not good for general purpose use. + * */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btSpinMutex extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSpinMutex(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSpinMutex(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSpinMutex position(long position) { + return (btSpinMutex)super.position(position); + } + @Override public btSpinMutex getPointer(long i) { + return new btSpinMutex((Pointer)this).offsetAddress(i); + } + + public btSpinMutex() { super((Pointer)null); allocate(); } + private native void allocate(); + public native void lock(); + public native void unlock(); + public native @Cast("bool") boolean tryLock(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btThreadSupportInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btThreadSupportInterface.java new file mode 100644 index 00000000000..b889526c72d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btThreadSupportInterface.java @@ -0,0 +1,71 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btThreadSupportInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btThreadSupportInterface(Pointer p) { super(p); } + + + public native int getNumWorkerThreads(); // number of worker threads (total number of logical processors - 1) + public native int getCacheFriendlyNumThreads(); // the number of logical processors sharing a single L3 cache + public native int getLogicalToPhysicalCoreRatio(); // the number of logical processors per physical processor (usually 1 or 2) + public native void runTask(int threadIndex, Pointer userData); + public native void waitForAllTasks(); + + public native btCriticalSection createCriticalSection(); + public native void deleteCriticalSection(btCriticalSection criticalSection); + + public static class ThreadFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ThreadFunc(Pointer p) { super(p); } + protected ThreadFunc() { allocate(); } + private native void allocate(); + public native void call(Pointer userPtr); + } + + @NoOffset public static class ConstructionInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ConstructionInfo(Pointer p) { super(p); } + + public ConstructionInfo(@Cast("const char*") BytePointer uniqueName, + ThreadFunc userThreadFunc, + int threadStackSize/*=65535*/) { super((Pointer)null); allocate(uniqueName, userThreadFunc, threadStackSize); } + private native void allocate(@Cast("const char*") BytePointer uniqueName, + ThreadFunc userThreadFunc, + int threadStackSize/*=65535*/); + public ConstructionInfo(@Cast("const char*") BytePointer uniqueName, + ThreadFunc userThreadFunc) { super((Pointer)null); allocate(uniqueName, userThreadFunc); } + private native void allocate(@Cast("const char*") BytePointer uniqueName, + ThreadFunc userThreadFunc); + public ConstructionInfo(String uniqueName, + ThreadFunc userThreadFunc, + int threadStackSize/*=65535*/) { super((Pointer)null); allocate(uniqueName, userThreadFunc, threadStackSize); } + private native void allocate(String uniqueName, + ThreadFunc userThreadFunc, + int threadStackSize/*=65535*/); + public ConstructionInfo(String uniqueName, + ThreadFunc userThreadFunc) { super((Pointer)null); allocate(uniqueName, userThreadFunc); } + private native void allocate(String uniqueName, + ThreadFunc userThreadFunc); + + public native @Cast("const char*") BytePointer m_uniqueName(); public native ConstructionInfo m_uniqueName(BytePointer setter); + public native ThreadFunc m_userThreadFunc(); public native ConstructionInfo m_userThreadFunc(ThreadFunc setter); + public native int m_threadStackSize(); public native ConstructionInfo m_threadStackSize(int setter); + } + + public static native btThreadSupportInterface create(@Const @ByRef ConstructionInfo info); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformUtil.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformUtil.java new file mode 100644 index 00000000000..1f65c31ba6a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btTransformUtil.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +/** Utils related to temporal transforms */ +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btTransformUtil extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTransformUtil() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTransformUtil(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTransformUtil(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTransformUtil position(long position) { + return (btTransformUtil)super.position(position); + } + @Override public btTransformUtil getPointer(long i) { + return new btTransformUtil((Pointer)this).offsetAddress(i); + } + + public static native void integrateTransform(@Const @ByRef btTransform curTrans, @Const @ByRef btVector3 linvel, @Const @ByRef btVector3 angvel, @Cast("btScalar") float timeStep, @ByRef btTransform predictedTransform); + + public static native void calculateVelocityQuaternion(@Const @ByRef btVector3 pos0, @Const @ByRef btVector3 pos1, @Const @ByRef btQuaternion orn0, @Const @ByRef btQuaternion orn1, @Cast("btScalar") float timeStep, @ByRef btVector3 linVel, @ByRef btVector3 angVel); + + public static native void calculateDiffAxisAngleQuaternion(@Const @ByRef btQuaternion orn0, @Const @ByRef btQuaternion orn1a, @ByRef btVector3 axis, @Cast("btScalar*") @ByRef FloatPointer angle); + public static native void calculateDiffAxisAngleQuaternion(@Const @ByRef btQuaternion orn0, @Const @ByRef btQuaternion orn1a, @ByRef btVector3 axis, @Cast("btScalar*") @ByRef FloatBuffer angle); + public static native void calculateDiffAxisAngleQuaternion(@Const @ByRef btQuaternion orn0, @Const @ByRef btQuaternion orn1a, @ByRef btVector3 axis, @Cast("btScalar*") @ByRef float[] angle); + + public static native void calculateVelocity(@Const @ByRef btTransform transform0, @Const @ByRef btTransform transform1, @Cast("btScalar") float timeStep, @ByRef btVector3 linVel, @ByRef btVector3 angVel); + + public static native void calculateDiffAxisAngle(@Const @ByRef btTransform transform0, @Const @ByRef btTransform transform1, @ByRef btVector3 axis, @Cast("btScalar*") @ByRef FloatPointer angle); + public static native void calculateDiffAxisAngle(@Const @ByRef btTransform transform0, @Const @ByRef btTransform transform1, @ByRef btVector3 axis, @Cast("btScalar*") @ByRef FloatBuffer angle); + public static native void calculateDiffAxisAngle(@Const @ByRef btTransform transform0, @Const @ByRef btTransform transform1, @ByRef btVector3 axis, @Cast("btScalar*") @ByRef float[] angle); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btUIntArray.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btUIntArray.java new file mode 100644 index 00000000000..9f7406b22a8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btUIntArray.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btUIntArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btUIntArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btUIntArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btUIntArray position(long position) { + return (btUIntArray)super.position(position); + } + @Override public btUIntArray getPointer(long i) { + return new btUIntArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btUIntArray put(@Const @ByRef btUIntArray other); + public btUIntArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btUIntArray(@Const @ByRef btUIntArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btUIntArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @Cast("unsigned int*") @ByRef IntPointer at(int n); + + public native @Cast("unsigned int*") @ByRef @Name("operator []") IntPointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Cast("const unsigned int") int fillData/*=unsigned int()*/); + public native void resize(int newsize); + public native @Cast("unsigned int*") @ByRef IntPointer expandNonInitializing(); + + public native @Cast("unsigned int*") @ByRef IntPointer expand(@Cast("const unsigned int") int fillValue/*=unsigned int()*/); + public native @Cast("unsigned int*") @ByRef IntPointer expand(); + + public native void push_back(@Cast("const unsigned int") int _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Cast("const unsigned int") int key); + + public native int findLinearSearch(@Cast("const unsigned int") int key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@Cast("const unsigned int") int key); + + public native void removeAtIndex(int index); + public native void remove(@Cast("const unsigned int") int key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btUIntArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index 268a35af759..015ec5fc405 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -725,6 +725,9 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // Targeting ../LinearMath/btIntArray.java +// Targeting ../LinearMath/btUIntArray.java + + // Targeting ../LinearMath/btScalarArray.java @@ -740,6 +743,15 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // Targeting ../LinearMath/btVector4Array.java +// Targeting ../LinearMath/btPlaneArray.java + + +// Targeting ../LinearMath/btConvexHHalfEdgeArray.java + + +// Targeting ../LinearMath/btConvexHullComputerEdgeArray.java + + // #endif //BT_OBJECT_ARRAY__ @@ -1119,4 +1131,377 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // #endif //BT_STACK_ALLOC +// Parsed from LinearMath/TaskScheduler/btThreadSupportInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2018 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_THREAD_SUPPORT_INTERFACE_H +// #define BT_THREAD_SUPPORT_INTERFACE_H +// Targeting ../LinearMath/btCriticalSection.java + + +// Targeting ../LinearMath/btThreadSupportInterface.java + + + +// #endif //BT_THREAD_SUPPORT_INTERFACE_H + + +// Parsed from LinearMath/btThreads.h + +/* +Copyright (c) 2003-2014 Erwin Coumans http://bullet.googlecode.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_THREADS_H +// #define BT_THREADS_H + +// #include "btScalar.h" // has definitions like SIMD_FORCE_INLINE + +// #if defined(_MSC_VER) && _MSC_VER >= 1600 +// give us a compile error if any signatures of overriden methods is changed +// #define BT_OVERRIDE override +// #endif + +// #ifndef BT_OVERRIDE +// #define BT_OVERRIDE +// #endif + +// Don't set this to larger than 64, without modifying btThreadSupportPosix +// and btThreadSupportWin32. They use UINT64 bit-masks. +@MemberGetter public static native @Cast("const unsigned int") int BT_MAX_THREAD_COUNT(); // only if BT_THREADSAFE is 1 + +// for internal use only +public static native @Cast("bool") boolean btIsMainThread(); +public static native @Cast("bool") boolean btThreadsAreRunning(); +public static native @Cast("unsigned int") int btGetCurrentThreadIndex(); + + +/// +/// +public static native void btResetThreadIndexCounter(); +// Targeting ../LinearMath/btSpinMutex.java + + + +// +// NOTE: btMutex* is for internal Bullet use only +// +// If BT_THREADSAFE is undefined or 0, should optimize away to nothing. +// This is good because for the single-threaded build of Bullet, any calls +// to these functions will be optimized out. +// +// However, for users of the multi-threaded build of Bullet this is kind +// of bad because if you call any of these functions from external code +// (where BT_THREADSAFE is undefined) you will get unexpected race conditions. +// +public static native void btMutexLock(btSpinMutex mutex); + +public static native void btMutexUnlock(btSpinMutex mutex); + +public static native @Cast("bool") boolean btMutexTryLock(btSpinMutex mutex); +// Targeting ../LinearMath/btIParallelForBody.java + + +// Targeting ../LinearMath/btIParallelSumBody.java + + +// Targeting ../LinearMath/btITaskScheduler.java + + + +// set the task scheduler to use for all calls to btParallelFor() +// NOTE: you must set this prior to using any of the multi-threaded "Mt" classes +public static native void btSetTaskScheduler(btITaskScheduler ts); + +// get the current task scheduler +public static native btITaskScheduler btGetTaskScheduler(); + +// get non-threaded task scheduler (always available) +public static native btITaskScheduler btGetSequentialTaskScheduler(); + +// create a default task scheduler (Win32 or pthreads based) +public static native btITaskScheduler btCreateDefaultTaskScheduler(); + +// get OpenMP task scheduler (if available, otherwise returns null) +public static native btITaskScheduler btGetOpenMPTaskScheduler(); + +// get Intel TBB task scheduler (if available, otherwise returns null) +public static native btITaskScheduler btGetTBBTaskScheduler(); + +// get PPL task scheduler (if available, otherwise returns null) +public static native btITaskScheduler btGetPPLTaskScheduler(); + +// btParallelFor -- call this to dispatch work like a for-loop +// (iterations may be done out of order, so no dependencies are allowed) +public static native void btParallelFor(int iBegin, int iEnd, int grainSize, @Const @ByRef btIParallelForBody body); + +// btParallelSum -- call this to dispatch work like a for-loop, returns the sum of all iterations +// (iterations may be done out of order, so no dependencies are allowed) +public static native @Cast("btScalar") float btParallelSum(int iBegin, int iEnd, int grainSize, @Const @ByRef btIParallelSumBody body); + +// #endif + + +// Parsed from LinearMath/btAlignedAllocator.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_ALIGNED_ALLOCATOR +// #define BT_ALIGNED_ALLOCATOR + +/**we probably replace this with our own aligned memory allocator + * so we replace _aligned_malloc and _aligned_free with our own + * that is better portable and more predictable */ + +// #include "btScalar.h" + +/**BT_DEBUG_MEMORY_ALLOCATIONS preprocessor can be set in build system + * for regression tests to detect memory leaks + * #define BT_DEBUG_MEMORY_ALLOCATIONS 1 */ +// #ifdef BT_DEBUG_MEMORY_ALLOCATIONS + +// #else +public static native Pointer btAlignedAllocInternal(@Cast("size_t") long size, int alignment); +public static native void btAlignedFreeInternal(Pointer ptr); + +// #define btAlignedAlloc(size, alignment) btAlignedAllocInternal(size, alignment) +// #define btAlignedFree(ptr) btAlignedFreeInternal(ptr) + +// #endif +// Targeting ../LinearMath/btAlignedAllocFunc.java + + +// Targeting ../LinearMath/btAlignedFreeFunc.java + + +// Targeting ../LinearMath/btAllocFunc.java + + +// Targeting ../LinearMath/btFreeFunc.java + + + +/**The developer can let all Bullet memory allocations go through a custom memory allocator, using btAlignedAllocSetCustom */ +public static native void btAlignedAllocSetCustom(btAllocFunc allocFunc, btFreeFunc freeFunc); +/**If the developer has already an custom aligned allocator, then btAlignedAllocSetCustomAligned can be used. The default aligned allocator pre-allocates extra memory using the non-aligned allocator, and instruments it. */ +public static native void btAlignedAllocSetCustomAligned(btAlignedAllocFunc allocFunc, btAlignedFreeFunc freeFunc); + +/**The btAlignedAllocator is a portable class for aligned memory allocations. + * Default implementations for unaligned and aligned allocations can be overridden by a custom allocator using btAlignedAllocSetCustom and btAlignedAllocSetCustomAligned. */ + +// #endif //BT_ALIGNED_ALLOCATOR + + +// Parsed from LinearMath/btConvexHull.h + + +/* +Stan Melax Convex Hull Computation +Copyright (c) 2008 Stan Melax http://www.melax.com/ + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**includes modifications/improvements by John Ratcliff, see BringOutYourDead below. */ + +// #ifndef BT_CD_HULL_H +// #define BT_CD_HULL_H + +// #include "btVector3.h" +// #include "btAlignedObjectArray.h" +// Targeting ../LinearMath/HullResult.java + + + +/** enum HullFlag */ +public static final int + QF_TRIANGLES = (1 << 0), // report results as triangles, not polygons. + QF_REVERSE_ORDER = (1 << 1), // reverse order of the triangle indices. + QF_DEFAULT = QF_TRIANGLES; +// Targeting ../LinearMath/HullDesc.java + + + +/** enum HullError */ +public static final int + QE_OK = 0, // success! + QE_FAIL = 1; // failed. +// Targeting ../LinearMath/btPlane.java + + +// Targeting ../LinearMath/ConvexH.java + + +// Targeting ../LinearMath/Int4.java + + +// Targeting ../LinearMath/PHullResult.java + + +// Targeting ../LinearMath/HullLibrary.java + + + +// #endif //BT_CD_HULL_H + + +// Parsed from LinearMath/btConvexHullComputer.h + +/* +Copyright (c) 2011 Ole Kniemeyer, MAXON, www.maxon.net + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_HULL_COMPUTER_H +// #define BT_CONVEX_HULL_COMPUTER_H + +// #include "btVector3.h" +// #include "btAlignedObjectArray.h" +// Targeting ../LinearMath/btConvexHullComputer.java + + + +// #endif //BT_CONVEX_HULL_COMPUTER_H + + +// Parsed from LinearMath/btGeometryUtil.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GEOMETRY_UTIL_H +// #define BT_GEOMETRY_UTIL_H + +// #include "btVector3.h" +// #include "btAlignedObjectArray.h" +// Targeting ../LinearMath/btGeometryUtil.java + + + +// #endif //BT_GEOMETRY_UTIL_H + + +// Parsed from LinearMath/btMinMax.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GEN_MINMAX_H +// #define BT_GEN_MINMAX_H + +// #include "btScalar.h" + +// #endif //BT_GEN_MINMAX_H + + +// Parsed from LinearMath/btTransformUtil.h + +/* +Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRANSFORM_UTIL_H +// #define BT_TRANSFORM_UTIL_H + +// #include "btTransform.h" +public static native @MemberGetter double ANGULAR_MOTION_THRESHOLD(); +public static final double ANGULAR_MOTION_THRESHOLD = ANGULAR_MOTION_THRESHOLD(); + +public static native @ByVal btVector3 btAabbSupport(@Const @ByRef btVector3 halfExtents, @Const @ByRef btVector3 supportDir); +// Targeting ../LinearMath/btTransformUtil.java + + +// Targeting ../LinearMath/btConvexSeparatingDistanceUtil.java + + + +// #endif //BT_TRANSFORM_UTIL_H + + } From af434746c1cbfdbd4cbed2ccdc4d16b6642006ee Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 28 Feb 2022 22:34:46 +0800 Subject: [PATCH 43/81] Map extra headers from bullet's BulletCollision Referenced from bullet's examples. --- .../bullet/presets/BulletCollision.java | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index 07722c0055f..eca8d709eef 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -58,6 +58,17 @@ "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h", "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h", "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h", + "BulletCollision/NarrowPhaseCollision/btConvexCast.h", + "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h", + "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h", + "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h", + "BulletCollision/NarrowPhaseCollision/btGjkEpa3.h", + "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h", + "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h", + "BulletCollision/NarrowPhaseCollision/btMprPenetration.h", + "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h", + "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h", + "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h", "BulletCollision/CollisionDispatch/btCollisionConfiguration.h", "BulletCollision/CollisionDispatch/btCollisionObject.h", "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h", @@ -70,6 +81,10 @@ "BulletCollision/CollisionDispatch/btSimulationIslandManager.h", "BulletCollision/CollisionDispatch/btUnionFind.h", "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h", + "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h", + "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h", "BulletCollision/CollisionShapes/btCollisionShape.h", "BulletCollision/CollisionShapes/btConvexShape.h", "BulletCollision/CollisionShapes/btConvexPolyhedron.h", @@ -98,6 +113,13 @@ "BulletCollision/CollisionShapes/btEmptyShape.h", "BulletCollision/CollisionShapes/btMultiSphereShape.h", "BulletCollision/CollisionShapes/btUniformScalingShape.h", + "BulletCollision/CollisionShapes/btBox2dShape.h", + "BulletCollision/CollisionShapes/btConvex2dShape.h", + "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h", + "BulletCollision/CollisionShapes/btTriangleShape.h", + "BulletCollision/CollisionShapes/btSdfCollisionShape.h", + "BulletCollision/CollisionShapes/btShapeHull.h", + "BulletCollision/Gimpact/btGImpactShape.h", }, link = "BulletCollision@.3.20" ) @@ -122,7 +144,10 @@ public void map(InfoMap infoMap) { .put(new Info("DBVT_INLINE").cppTypes().annotations()) .put(new Info( + "BT_DECLARE_STACK_ONLY_OBJECT", + "BT_INTERNAL_EDGE_DEBUG_DRAW", "DBVT_BP_PROFILE", + "DEBUG_MPR", "DEBUG_PERSISTENCY", "NO_VIRTUAL_INTERFACE", "PFX_USE_FREE_VECTORMATH", @@ -139,9 +164,12 @@ public void map(InfoMap infoMap) { .put(new Info("btPersistentManifold.h").linePatterns("struct btCollisionResult;").skip()) .put(new Info( + "BT_MPR_FABS", + "BT_MPR_SQRT", "DBVT_CHECKTYPE", "DBVT_IPOLICY", "DBVT_PREFIX", + "btAABB", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", @@ -163,11 +191,17 @@ public void map(InfoMap infoMap) { "btDbvt::rayTestInternal", "btDbvtBroadphase::m_rayTestStacks", "btDbvtProxy", + "btGImpactBoxSet", + "btGImpactMeshShapePart::TrimeshPrimitiveManager", + "btGImpactCompoundShape::CompoundPrimitiveManager", + "btGImpactShapeInterface::getPrimitiveTriangle", "btHashedOverlappingPairCache::getOverlappingPairArray", "btNullPairCache::getOverlappingPairArray", "btOverlappingPairCache::getOverlappingPairArray", + "btPrimitiveManagerBase", "btSortedOverlappingPairCache::getOverlappingPairArray", "btSphereSphereCollisionAlgorithm::getAllContactManifolds", + "btTriangleShapeEx", "gContactDestroyedCallback", "gContactEndedCallback", "gContactProcessedCallback", From 5a05437994ea4417a8048fb84ca7b0e335d4f72b Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 28 Feb 2022 22:37:52 +0800 Subject: [PATCH 44/81] Update generated code of bullet preset See parent commit. --- .../BulletCollision/_btMprSimplex_t.java | 38 + .../BulletCollision/_btMprSupport_t.java | 40 + .../btBox2dBox2dCollisionAlgorithm.java | 54 + .../bullet/BulletCollision/btBox2dShape.java | 75 ++ .../btContinuousConvexCollision.java | 38 + .../btConvex2dConvex2dAlgorithm.java | 52 + .../BulletCollision/btConvex2dShape.java | 56 + .../bullet/BulletCollision/btConvexCast.java | 74 ++ .../BulletCollision/btEmptyAlgorithm.java | 53 + .../btGImpactCompoundShape.java | 90 ++ .../BulletCollision/btGImpactMeshShape.java | 106 ++ .../btGImpactMeshShapeData.java | 44 + .../btGImpactMeshShapePart.java | 104 ++ .../btGImpactShapeInterface.java | 127 ++ .../BulletCollision/btGjkConvexCast.java | 33 + .../BulletCollision/btGjkEpaSolver2.java | 92 ++ .../BulletCollision/btGjkEpaSolver3.java | 62 + .../BulletCollision/btGjkPairDetector.java | 52 + .../btHeightfieldTerrainShape.java | 260 ++++ .../btMinkowskiPenetrationDepthSolver.java | 41 + .../BulletCollision/btMinkowskiSumShape.java | 21 + .../btMprCollisionDescription.java | 40 + .../BulletCollision/btMprDistanceInfo.java | 38 + .../BulletCollision/btMprSimplex_t.java | 21 + .../BulletCollision/btMprSupport_t.java | 21 + .../btPolyhedralContactClipping.java | 43 + .../BulletCollision/btSdfCollisionShape.java | 50 + .../bullet/BulletCollision/btShapeHull.java | 38 + .../btSubsimplexConvexCast.java | 38 + .../BulletCollision/btTetrahedronShapeEx.java | 38 + .../btTriangleConvexcastCallback.java | 33 + .../btTriangleRaycastCallback.java | 44 + .../BulletCollision/btTriangleShape.java | 73 ++ .../bullet/global/BulletCollision.java | 1047 ++++++++++++++++- 34 files changed, 2975 insertions(+), 61 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/_btMprSimplex_t.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/_btMprSupport_t.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBox2dBox2dCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBox2dShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContinuousConvexCollision.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvex2dConvex2dAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvex2dShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexCast.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCompoundShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapePart.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactShapeInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkConvexCast.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaSolver2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaSolver3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkPairDetector.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHeightfieldTerrainShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiPenetrationDepthSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiSumShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprCollisionDescription.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprDistanceInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprSimplex_t.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprSupport_t.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralContactClipping.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSdfCollisionShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeHull.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubsimplexConvexCast.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTetrahedronShapeEx.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleConvexcastCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleRaycastCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleShape.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/_btMprSimplex_t.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/_btMprSimplex_t.java new file mode 100644 index 00000000000..2242af60c1b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/_btMprSimplex_t.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class _btMprSimplex_t extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public _btMprSimplex_t() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public _btMprSimplex_t(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _btMprSimplex_t(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public _btMprSimplex_t position(long position) { + return (_btMprSimplex_t)super.position(position); + } + @Override public _btMprSimplex_t getPointer(long i) { + return new _btMprSimplex_t((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMprSupport_t ps(int i); public native _btMprSimplex_t ps(int i, btMprSupport_t setter); + @MemberGetter public native btMprSupport_t ps(); + /** index of last added point */ + public native int last(); public native _btMprSimplex_t last(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/_btMprSupport_t.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/_btMprSupport_t.java new file mode 100644 index 00000000000..e543d038060 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/_btMprSupport_t.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class _btMprSupport_t extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public _btMprSupport_t() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public _btMprSupport_t(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _btMprSupport_t(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public _btMprSupport_t position(long position) { + return (_btMprSupport_t)super.position(position); + } + @Override public _btMprSupport_t getPointer(long i) { + return new _btMprSupport_t((Pointer)this).offsetAddress(i); + } + + /** Support point in minkowski sum */ + public native @ByRef btVector3 v(); public native _btMprSupport_t v(btVector3 setter); + /** Support point in obj1 */ + public native @ByRef btVector3 v1(); public native _btMprSupport_t v1(btVector3 setter); + /** Support point in obj2 */ + public native @ByRef btVector3 v2(); public native _btMprSupport_t v2(btVector3 setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBox2dBox2dCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBox2dBox2dCollisionAlgorithm.java new file mode 100644 index 00000000000..0beeee19446 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBox2dBox2dCollisionAlgorithm.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**box-box collision detection */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBox2dBox2dCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBox2dBox2dCollisionAlgorithm(Pointer p) { super(p); } + + public btBox2dBox2dCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public btBox2dBox2dCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap) { super((Pointer)null); allocate(mf, ci, body0Wrap, body1Wrap); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBox2dShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBox2dShape.java new file mode 100644 index 00000000000..1967403c5d3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBox2dShape.java @@ -0,0 +1,75 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btBox2dShape is a box primitive around the origin, its sides axis aligned with length specified by half extents, in local shape coordinates. When used as part of a btCollisionObject or btRigidBody it will be an oriented box in world space. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBox2dShape extends btPolyhedralConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBox2dShape(Pointer p) { super(p); } + + + public native @ByVal btVector3 getHalfExtentsWithMargin(); + + public native @Const @ByRef btVector3 getHalfExtentsWithoutMargin(); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + /**a btBox2dShape is a flat 2D box in the X-Y plane (Z extents are zero) */ + public btBox2dShape(@Const @ByRef btVector3 boxHalfExtents) { super((Pointer)null); allocate(boxHalfExtents); } + private native void allocate(@Const @ByRef btVector3 boxHalfExtents); + + public native void setMargin(@Cast("btScalar") float collisionMargin); + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native int getVertexCount(); + + public native int getNumVertices(); + + public native @Const btVector3 getVertices(); + + public native @Const btVector3 getNormals(); + + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + + public native @Const @ByRef btVector3 getCentroid(); + + public native int getNumPlanes(); + + public native int getNumEdges(); + + public native void getVertex(int i, @ByRef btVector3 vtx); + + public native void getPlaneEquation(@ByRef btVector4 plane, int i); + + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContinuousConvexCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContinuousConvexCollision.java new file mode 100644 index 00000000000..83ac1d5b568 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContinuousConvexCollision.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btContinuousConvexCollision implements angular and linear time of impact for convex objects. + * Based on Brian Mirtich's Conservative Advancement idea (PhD thesis). + * Algorithm operates in worldspace, in order to keep in between motion globally consistent. + * It uses GJK at the moment. Future improvement would use minkowski sum / supporting vertex, merging innerloops */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btContinuousConvexCollision extends btConvexCast { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContinuousConvexCollision(Pointer p) { super(p); } + + public btContinuousConvexCollision(@Const btConvexShape shapeA, @Const btConvexShape shapeB, btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver penetrationDepthSolver) { super((Pointer)null); allocate(shapeA, shapeB, simplexSolver, penetrationDepthSolver); } + private native void allocate(@Const btConvexShape shapeA, @Const btConvexShape shapeB, btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver penetrationDepthSolver); + + public btContinuousConvexCollision(@Const btConvexShape shapeA, @Const btStaticPlaneShape plane) { super((Pointer)null); allocate(shapeA, plane); } + private native void allocate(@Const btConvexShape shapeA, @Const btStaticPlaneShape plane); + + public native @Cast("bool") boolean calcTimeOfImpact( + @Const @ByRef btTransform fromA, + @Const @ByRef btTransform toA, + @Const @ByRef btTransform fromB, + @Const @ByRef btTransform toB, + @ByRef CastResult result); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvex2dConvex2dAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvex2dConvex2dAlgorithm.java new file mode 100644 index 00000000000..350ef8801bf --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvex2dConvex2dAlgorithm.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The convex2dConvex2dAlgorithm collision algorithm support 2d collision detection for btConvex2dShape + * Currently it requires the btMinkowskiPenetrationDepthSolver, it has support for 2d penetration depth computation */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvex2dConvex2dAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvex2dConvex2dAlgorithm(Pointer p) { super(p); } + + public btConvex2dConvex2dAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold) { super((Pointer)null); allocate(mf, ci, body0Wrap, body1Wrap, simplexSolver, pdSolver, numPerturbationIterations, minimumPointsPerturbationThreshold); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public native void setLowLevelOfDetail(@Cast("bool") boolean useLowLevel); + + public native @Const btPersistentManifold getManifold(); + + @NoOffset public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + + public native btConvexPenetrationDepthSolver m_pdSolver(); public native CreateFunc m_pdSolver(btConvexPenetrationDepthSolver setter); + public native btSimplexSolverInterface m_simplexSolver(); public native CreateFunc m_simplexSolver(btSimplexSolverInterface setter); + public native int m_numPerturbationIterations(); public native CreateFunc m_numPerturbationIterations(int setter); + public native int m_minimumPointsPerturbationThreshold(); public native CreateFunc m_minimumPointsPerturbationThreshold(int setter); + + public CreateFunc(btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver pdSolver) { super((Pointer)null); allocate(simplexSolver, pdSolver); } + private native void allocate(btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver pdSolver); + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvex2dShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvex2dShape.java new file mode 100644 index 00000000000..f11a134dd71 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvex2dShape.java @@ -0,0 +1,56 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + // for the types + +/**The btConvex2dShape allows to use arbitrary convex shapes as 2d convex shapes, with the Z component assumed to be 0. + * For 2d boxes, the btBox2dShape is recommended. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvex2dShape extends btConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvex2dShape(Pointer p) { super(p); } + + + public btConvex2dShape(btConvexShape convexChildShape) { super((Pointer)null); allocate(convexChildShape); } + private native void allocate(btConvexShape convexChildShape); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native btConvexShape getChildShape(); + + public native @Cast("const char*") BytePointer getName(); + + /////////////////////////// + + /**getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void getAabbSlow(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexCast.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexCast.java new file mode 100644 index 00000000000..e669d8d80b7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexCast.java @@ -0,0 +1,74 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +// #endif +/**Typically the conservative advancement reaches solution in a few iterations, clip it to 32 for degenerate cases. + * See discussion about this here https://bulletphysics.orgphpBB2/viewtopic.php?t=565 */ +//will need to digg deeper to make the algorithm more robust +//since, a large epsilon can cause an early termination with false +//positive results (ray intersections that shouldn't be there) + +/** btConvexCast is an interface for Casting */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexCast extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexCast(Pointer p) { super(p); } + + + /**RayResult stores the closest result + * alternatively, add a callback method to decide about closest/all results */ + @NoOffset public static class CastResult extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CastResult(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CastResult(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public CastResult position(long position) { + return (CastResult)super.position(position); + } + @Override public CastResult getPointer(long i) { + return new CastResult((Pointer)this).offsetAddress(i); + } + + //virtual bool addRayResult(const btVector3& normal,btScalar fraction) = 0; + + public native void DebugDraw(@Cast("btScalar") float fraction); + public native void drawCoordSystem(@Const @ByRef btTransform trans); + public native void reportFailure(int errNo, int numIterations); + public CastResult() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @ByRef btTransform m_hitTransformA(); public native CastResult m_hitTransformA(btTransform setter); + public native @ByRef btTransform m_hitTransformB(); public native CastResult m_hitTransformB(btTransform setter); + public native @ByRef btVector3 m_normal(); public native CastResult m_normal(btVector3 setter); + public native @ByRef btVector3 m_hitPoint(); public native CastResult m_hitPoint(btVector3 setter); + public native @Cast("btScalar") float m_fraction(); public native CastResult m_fraction(float setter); //input and output + public native btIDebugDraw m_debugDrawer(); public native CastResult m_debugDrawer(btIDebugDraw setter); + public native @Cast("btScalar") float m_allowedPenetration(); public native CastResult m_allowedPenetration(float setter); + + public native int m_subSimplexCastMaxIterations(); public native CastResult m_subSimplexCastMaxIterations(int setter); + public native @Cast("btScalar") float m_subSimplexCastEpsilon(); public native CastResult m_subSimplexCastEpsilon(float setter); + + } + + /** cast a convex against another convex object */ + public native @Cast("bool") boolean calcTimeOfImpact( + @Const @ByRef btTransform fromA, + @Const @ByRef btTransform toA, + @Const @ByRef btTransform fromB, + @Const @ByRef btTransform toB, + @ByRef CastResult result); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyAlgorithm.java new file mode 100644 index 00000000000..96c2e99b32b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btEmptyAlgorithm.java @@ -0,0 +1,53 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**EmptyAlgorithm is a stub for unsupported collision pairs. + * The dispatcher can dispatch a persistent btEmptyAlgorithm to avoid a search every frame. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btEmptyAlgorithm extends btCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btEmptyAlgorithm(Pointer p) { super(p); } + + public btEmptyAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCompoundShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCompoundShape.java new file mode 100644 index 00000000000..ff2566746c7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCompoundShape.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btGImpactCompoundShape allows to handle multiple btCollisionShape objects at once +/** +This class only can manage Convex subshapes +*/ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGImpactCompoundShape extends btGImpactShapeInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGImpactCompoundShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGImpactCompoundShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btGImpactCompoundShape position(long position) { + return (btGImpactCompoundShape)super.position(position); + } + @Override public btGImpactCompoundShape getPointer(long i) { + return new btGImpactCompoundShape((Pointer)this).offsetAddress(i); + } + + /** compound primitive manager */ + public btGImpactCompoundShape(@Cast("bool") boolean children_has_transform/*=true*/) { super((Pointer)null); allocate(children_has_transform); } + private native void allocate(@Cast("bool") boolean children_has_transform/*=true*/); + public btGImpactCompoundShape() { super((Pointer)null); allocate(); } + private native void allocate(); + + /** if true, then its children must get transforms. */ + public native @Cast("bool") boolean childrenHasTransform(); + + /** Obtains the primitive manager */ + + /** Obtains the compopund primitive manager */ + + /** Gets the number of children */ + public native int getNumChildShapes(); + + /** Use this method for adding children. Only Convex shapes are allowed. */ + public native void addChildShape(@Const @ByRef btTransform localTransform, btCollisionShape shape); + + /** Use this method for adding children. Only Convex shapes are allowed. */ + public native void addChildShape(btCollisionShape shape); + + /** Gets the children */ + public native btCollisionShape getChildShape(int index); + + /** Gets the children */ + + /** Retrieves the bound from a child + /** + */ + public native void getChildAabb(int child_index, @Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /** Gets the children transform */ + public native @ByVal btTransform getChildTransform(int index); + + /** Sets the children transform + /** + \post You must call updateBound() for update the box set. + */ + public native void setChildTransform(int index, @Const @ByRef btTransform transform); + + /** Determines if this shape has triangles */ + public native @Cast("bool") boolean needsRetrieveTriangles(); + + /** Determines if this shape has tetrahedrons */ + public native @Cast("bool") boolean needsRetrieveTetrahedrons(); + + public native void getBulletTetrahedron(int prim_index, @ByRef btTetrahedronShapeEx tetrahedron); + + /** Calculates the exact inertia tensor for this shape */ + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("const char*") BytePointer getName(); + + public native @Cast("eGIMPACT_SHAPE_TYPE") int getGImpactShapeType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShape.java new file mode 100644 index 00000000000..2cb6463b3bd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShape.java @@ -0,0 +1,106 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** This class manages a mesh supplied by the btStridingMeshInterface interface. +/** +Set of btGImpactMeshShapePart parts +- Simply create this shape by passing the btStridingMeshInterface to the constructor btGImpactMeshShape, then you must call updateBound() after creating the mesh +

+- You can handle deformable meshes with this shape, by calling postUpdate() every time when changing the mesh vertices. +

+*/ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGImpactMeshShape extends btGImpactShapeInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGImpactMeshShape(Pointer p) { super(p); } + + public btGImpactMeshShape(btStridingMeshInterface meshInterface) { super((Pointer)null); allocate(meshInterface); } + private native void allocate(btStridingMeshInterface meshInterface); + + public native btStridingMeshInterface getMeshInterface(); + + public native int getMeshPartCount(); + + public native btGImpactMeshShapePart getMeshPart(int index); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native void setMargin(@Cast("btScalar") float margin); + + /** Tells to this object that is needed to refit all the meshes */ + public native void postUpdate(); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + /** Obtains the primitive manager */ + + /** Gets the number of children */ + public native int getNumChildShapes(); + + /** if true, then its children must get transforms. */ + public native @Cast("bool") boolean childrenHasTransform(); + + /** Determines if this shape has triangles */ + public native @Cast("bool") boolean needsRetrieveTriangles(); + + /** Determines if this shape has tetrahedrons */ + public native @Cast("bool") boolean needsRetrieveTetrahedrons(); + + public native void getBulletTetrahedron(int prim_index, @ByRef btTetrahedronShapeEx tetrahedron); + + /** call when reading child shapes */ + public native void lockChildShapes(); + + public native void unlockChildShapes(); + + /** Retrieves the bound from a child + /** + */ + public native void getChildAabb(int child_index, @Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /** Gets the children */ + public native btCollisionShape getChildShape(int index); + + /** Gets the child */ + + /** Gets the children transform */ + public native @ByVal btTransform getChildTransform(int index); + + /** Sets the children transform + /** + \post You must call updateBound() for update the box set. + */ + public native void setChildTransform(int index, @Const @ByRef btTransform transform); + + public native @Cast("eGIMPACT_SHAPE_TYPE") int getGImpactShapeType(); + + public native @Cast("const char*") BytePointer getName(); + + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btCollisionWorld.RayResultCallback resultCallback); + + /** Function for retrieve triangles. + /** + It gives the triangles in local space + */ + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void processAllTrianglesRay(btTriangleCallback callback, @Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapeData.java new file mode 100644 index 00000000000..3ea22a30be7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapeData.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGImpactMeshShapeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGImpactMeshShapeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGImpactMeshShapeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGImpactMeshShapeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGImpactMeshShapeData position(long position) { + return (btGImpactMeshShapeData)super.position(position); + } + @Override public btGImpactMeshShapeData getPointer(long i) { + return new btGImpactMeshShapeData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionShapeData m_collisionShapeData(); public native btGImpactMeshShapeData m_collisionShapeData(btCollisionShapeData setter); + + public native @ByRef btStridingMeshInterfaceData m_meshInterface(); public native btGImpactMeshShapeData m_meshInterface(btStridingMeshInterfaceData setter); + + public native @ByRef btVector3FloatData m_localScaling(); public native btGImpactMeshShapeData m_localScaling(btVector3FloatData setter); + + public native float m_collisionMargin(); public native btGImpactMeshShapeData m_collisionMargin(float setter); + + public native int m_gimpactSubType(); public native btGImpactMeshShapeData m_gimpactSubType(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapePart.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapePart.java new file mode 100644 index 00000000000..32e83166522 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapePart.java @@ -0,0 +1,104 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** This class manages a sub part of a mesh supplied by the btStridingMeshInterface interface. +/** +- Simply create this shape by passing the btStridingMeshInterface to the constructor btGImpactMeshShapePart, then you must call updateBound() after creating the mesh +- When making operations with this shape, you must call lock before accessing to the trimesh primitives, and then call unlock +- You can handle deformable meshes with this shape, by calling postUpdate() every time when changing the mesh vertices. +

+*/ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGImpactMeshShapePart extends btGImpactShapeInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGImpactMeshShapePart(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGImpactMeshShapePart(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btGImpactMeshShapePart position(long position) { + return (btGImpactMeshShapePart)super.position(position); + } + @Override public btGImpactMeshShapePart getPointer(long i) { + return new btGImpactMeshShapePart((Pointer)this).offsetAddress(i); + } + + /** Trimesh primitive manager + /** + Manages the info from btStridingMeshInterface object and controls the Lock/Unlock mechanism + */ + public btGImpactMeshShapePart() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btGImpactMeshShapePart(btStridingMeshInterface meshInterface, int part) { super((Pointer)null); allocate(meshInterface, part); } + private native void allocate(btStridingMeshInterface meshInterface, int part); + + /** if true, then its children must get transforms. */ + public native @Cast("bool") boolean childrenHasTransform(); + + /** call when reading child shapes */ + public native void lockChildShapes(); + public native void unlockChildShapes(); + + /** Gets the number of children */ + public native int getNumChildShapes(); + + /** Gets the children */ + public native btCollisionShape getChildShape(int index); + + /** Gets the child */ + + /** Gets the children transform */ + public native @ByVal btTransform getChildTransform(int index); + + /** Sets the children transform + /** + \post You must call updateBound() for update the box set. + */ + public native void setChildTransform(int index, @Const @ByRef btTransform transform); + + /** Obtains the primitive manager */ + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("const char*") BytePointer getName(); + + public native @Cast("eGIMPACT_SHAPE_TYPE") int getGImpactShapeType(); + + /** Determines if this shape has triangles */ + public native @Cast("bool") boolean needsRetrieveTriangles(); + + /** Determines if this shape has tetrahedrons */ + public native @Cast("bool") boolean needsRetrieveTetrahedrons(); + + public native void getBulletTetrahedron(int prim_index, @ByRef btTetrahedronShapeEx tetrahedron); + + public native int getVertexCount(); + + public native void getVertex(int vertex_index, @ByRef btVector3 vertex); + + public native void setMargin(@Cast("btScalar") float margin); + + public native @Cast("btScalar") float getMargin(); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native @Const @ByRef btVector3 getLocalScaling(); + + public native int getPart(); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + public native void processAllTrianglesRay(btTriangleCallback callback, @Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactShapeInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactShapeInterface.java new file mode 100644 index 00000000000..7a80d160e57 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactShapeInterface.java @@ -0,0 +1,127 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Base class for gimpact shapes */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGImpactShapeInterface extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGImpactShapeInterface(Pointer p) { super(p); } + + + /** performs refit operation + /** + Updates the entire Box set of this shape. + \pre postUpdate() must be called for attemps to calculating the box set, else this function + will does nothing. + \post if m_needs_update == true, then it calls calcLocalAABB(); + */ + public native void updateBound(); + + /** If the Bounding box is not updated, then this class attemps to calculate it. + /** + \post Calls updateBound() for update the box set. + */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /** Tells to this object that is needed to refit the box set */ + public native void postUpdate(); + + /** Obtains the local box, which is the global calculated box of the total of subshapes */ + + public native int getShapeType(); + + /** + \post You must call updateBound() for update the box set. + */ + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void setMargin(@Cast("btScalar") float margin); + + /** Subshape member functions + * \{ +

+ * Base method for determinig which kind of GIMPACT shape we get */ + public native @Cast("eGIMPACT_SHAPE_TYPE") int getGImpactShapeType(); + + /** gets boxset */ + + /** Determines if this class has a hierarchy structure for sorting its primitives */ + public native @Cast("bool") boolean hasBoxSet(); + + /** Obtains the primitive manager */ + + /** Gets the number of children */ + public native int getNumChildShapes(); + + /** if true, then its children must get transforms. */ + public native @Cast("bool") boolean childrenHasTransform(); + + /** Determines if this shape has triangles */ + public native @Cast("bool") boolean needsRetrieveTriangles(); + + /** Determines if this shape has tetrahedrons */ + public native @Cast("bool") boolean needsRetrieveTetrahedrons(); + + public native void getBulletTetrahedron(int prim_index, @ByRef btTetrahedronShapeEx tetrahedron); + + /** call when reading child shapes */ + public native void lockChildShapes(); + + public native void unlockChildShapes(); + + /** if this trimesh */ + + + /** Retrieves the bound from a child + /** + */ + public native void getChildAabb(int child_index, @Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + /** Gets the children */ + public native btCollisionShape getChildShape(int index); + + /** Gets the child */ + + /** Gets the children transform */ + public native @ByVal btTransform getChildTransform(int index); + + /** Sets the children transform + /** + \post You must call updateBound() for update the box set. + */ + public native void setChildTransform(int index, @Const @ByRef btTransform transform); + + /**\} +

+ * virtual method for ray collision */ + public native void rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @ByRef btCollisionWorld.RayResultCallback resultCallback); + + /** Function for retrieve triangles. + /** + It gives the triangles in local space + */ + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + /** Function for retrieve triangles. + /** + It gives the triangles in local space + */ + public native void processAllTrianglesRay(btTriangleCallback arg0, @Const @ByRef btVector3 arg1, @Const @ByRef btVector3 arg2); + + /**\} */ +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkConvexCast.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkConvexCast.java new file mode 100644 index 00000000000..fcbbebdec6b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkConvexCast.java @@ -0,0 +1,33 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**GjkConvexCast performs a raycast on a convex object using support mapping. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGjkConvexCast extends btConvexCast { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGjkConvexCast(Pointer p) { super(p); } + + public btGjkConvexCast(@Const btConvexShape convexA, @Const btConvexShape convexB, btSimplexSolverInterface simplexSolver) { super((Pointer)null); allocate(convexA, convexB, simplexSolver); } + private native void allocate(@Const btConvexShape convexA, @Const btConvexShape convexB, btSimplexSolverInterface simplexSolver); + + /** cast a convex against another convex object */ + public native @Cast("bool") boolean calcTimeOfImpact( + @Const @ByRef btTransform fromA, + @Const @ByRef btTransform toA, + @Const @ByRef btTransform fromB, + @Const @ByRef btTransform toB, + @ByRef CastResult result); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaSolver2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaSolver2.java new file mode 100644 index 00000000000..2a5e74873c3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaSolver2.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btGjkEpaSolver contributed under zlib by Nathanael Presson */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGjkEpaSolver2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGjkEpaSolver2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGjkEpaSolver2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGjkEpaSolver2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGjkEpaSolver2 position(long position) { + return (btGjkEpaSolver2)super.position(position); + } + @Override public btGjkEpaSolver2 getPointer(long i) { + return new btGjkEpaSolver2((Pointer)this).offsetAddress(i); + } + + public static class sResults extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public sResults() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sResults(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sResults(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public sResults position(long position) { + return (sResults)super.position(position); + } + @Override public sResults getPointer(long i) { + return new sResults((Pointer)this).offsetAddress(i); + } + + /** enum btGjkEpaSolver2::sResults::eStatus */ + public static final int + Separated = 0, /* Shapes doesnt penetrate */ + Penetrating = 1, /* Shapes are penetrating */ + GJK_Failed = 2, /* GJK phase fail, no big issue, shapes are probably just 'touching' */ + EPA_Failed = 3; /* EPA phase fail, bigger problem, need to save parameters, and debug */ + public native @ByRef btVector3 witnesses(int i); public native sResults witnesses(int i, btVector3 setter); + @MemberGetter public native btVector3 witnesses(); + public native @ByRef btVector3 normal(); public native sResults normal(btVector3 setter); + public native @Cast("btScalar") float distance(); public native sResults distance(float setter); + } + + public static native int StackSizeRequirement(); + + public static native @Cast("bool") boolean Distance(@Const btConvexShape shape0, @Const @ByRef btTransform wtrs0, + @Const btConvexShape shape1, @Const @ByRef btTransform wtrs1, + @Const @ByRef btVector3 guess, + @ByRef sResults results); + + public static native @Cast("bool") boolean Penetration(@Const btConvexShape shape0, @Const @ByRef btTransform wtrs0, + @Const btConvexShape shape1, @Const @ByRef btTransform wtrs1, + @Const @ByRef btVector3 guess, + @ByRef sResults results, + @Cast("bool") boolean usemargins/*=true*/); + public static native @Cast("bool") boolean Penetration(@Const btConvexShape shape0, @Const @ByRef btTransform wtrs0, + @Const btConvexShape shape1, @Const @ByRef btTransform wtrs1, + @Const @ByRef btVector3 guess, + @ByRef sResults results); +// #ifndef __SPU__ + public static native @Cast("btScalar") float SignedDistance(@Const @ByRef btVector3 _position, + @Cast("btScalar") float margin, + @Const btConvexShape shape, + @Const @ByRef btTransform wtrs, + @ByRef sResults results); + + public static native @Cast("bool") boolean SignedDistance(@Const btConvexShape shape0, @Const @ByRef btTransform wtrs0, + @Const btConvexShape shape1, @Const @ByRef btTransform wtrs1, + @Const @ByRef btVector3 guess, + @ByRef sResults results); +// #endif //__SPU__ +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaSolver3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaSolver3.java new file mode 100644 index 00000000000..7cd17208660 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkEpaSolver3.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGjkEpaSolver3 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btGjkEpaSolver3() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGjkEpaSolver3(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGjkEpaSolver3(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btGjkEpaSolver3 position(long position) { + return (btGjkEpaSolver3)super.position(position); + } + @Override public btGjkEpaSolver3 getPointer(long i) { + return new btGjkEpaSolver3((Pointer)this).offsetAddress(i); + } + + public static class sResults extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public sResults() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sResults(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sResults(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public sResults position(long position) { + return (sResults)super.position(position); + } + @Override public sResults getPointer(long i) { + return new sResults((Pointer)this).offsetAddress(i); + } + + /** enum btGjkEpaSolver3::sResults::eStatus */ + public static final int + Separated = 0, /* Shapes doesnt penetrate */ + Penetrating = 1, /* Shapes are penetrating */ + GJK_Failed = 2, /* GJK phase fail, no big issue, shapes are probably just 'touching' */ + EPA_Failed = 3; /* EPA phase fail, bigger problem, need to save parameters, and debug */ + public native @ByRef btVector3 witnesses(int i); public native sResults witnesses(int i, btVector3 setter); + @MemberGetter public native btVector3 witnesses(); + public native @ByRef btVector3 normal(); public native sResults normal(btVector3 setter); + public native @Cast("btScalar") float distance(); public native sResults distance(float setter); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkPairDetector.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkPairDetector.java new file mode 100644 index 00000000000..d04fa824c01 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkPairDetector.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btGjkPairDetector uses GJK to implement the btDiscreteCollisionDetectorInterface */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGjkPairDetector extends btDiscreteCollisionDetectorInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGjkPairDetector(Pointer p) { super(p); } + + //some debugging to fix degeneracy problems + public native int m_lastUsedMethod(); public native btGjkPairDetector m_lastUsedMethod(int setter); + public native int m_curIter(); public native btGjkPairDetector m_curIter(int setter); + public native int m_degenerateSimplex(); public native btGjkPairDetector m_degenerateSimplex(int setter); + public native int m_catchDegeneracies(); public native btGjkPairDetector m_catchDegeneracies(int setter); + public native int m_fixContactNormalDirection(); public native btGjkPairDetector m_fixContactNormalDirection(int setter); + + public btGjkPairDetector(@Const btConvexShape objectA, @Const btConvexShape objectB, btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver penetrationDepthSolver) { super((Pointer)null); allocate(objectA, objectB, simplexSolver, penetrationDepthSolver); } + private native void allocate(@Const btConvexShape objectA, @Const btConvexShape objectB, btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver penetrationDepthSolver); + public btGjkPairDetector(@Const btConvexShape objectA, @Const btConvexShape objectB, int shapeTypeA, int shapeTypeB, @Cast("btScalar") float marginA, @Cast("btScalar") float marginB, btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver penetrationDepthSolver) { super((Pointer)null); allocate(objectA, objectB, shapeTypeA, shapeTypeB, marginA, marginB, simplexSolver, penetrationDepthSolver); } + private native void allocate(@Const btConvexShape objectA, @Const btConvexShape objectB, int shapeTypeA, int shapeTypeB, @Cast("btScalar") float marginA, @Cast("btScalar") float marginB, btSimplexSolverInterface simplexSolver, btConvexPenetrationDepthSolver penetrationDepthSolver); + + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw, @Cast("bool") boolean swapResults/*=false*/); + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw); + + public native void getClosestPointsNonVirtual(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw); + + public native void setMinkowskiA(@Const btConvexShape minkA); + + public native void setMinkowskiB(@Const btConvexShape minkB); + public native void setCachedSeparatingAxis(@Const @ByRef btVector3 separatingAxis); + + public native @Const @ByRef btVector3 getCachedSeparatingAxis(); + public native @Cast("btScalar") float getCachedSeparatingDistance(); + + public native void setPenetrationDepthSolver(btConvexPenetrationDepthSolver penetrationDepthSolver); + + /**don't use setIgnoreMargin, it's for Bullet's internal use */ + public native void setIgnoreMargin(@Cast("bool") boolean ignoreMargin); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHeightfieldTerrainShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHeightfieldTerrainShape.java new file mode 100644 index 00000000000..98cb123885a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHeightfieldTerrainShape.java @@ -0,0 +1,260 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btHeightfieldTerrainShape simulates a 2D heightfield terrain +/** + The caller is responsible for maintaining the heightfield array; this + class does not make a copy. +

+ The heightfield can be dynamic so long as the min/max height values + capture the extremes (heights must always be in that range). +

+ The local origin of the heightfield is assumed to be the exact + center (as determined by width and length and height, with each + axis multiplied by the localScaling). +

+ \b NOTE: be careful with coordinates. If you have a heightfield with a local + min height of -100m, and a max height of +500m, you may be tempted to place it + at the origin (0,0) and expect the heights in world coordinates to be + -100 to +500 meters. + Actually, the heights will be -300 to +300m, because bullet will re-center + the heightfield based on its AABB (which is determined by the min/max + heights). So keep in mind that once you create a btHeightfieldTerrainShape + object, the heights will be adjusted relative to the center of the AABB. This + is different to the behavior of many rendering engines, but is useful for + physics engines. +

+ Most (but not all) rendering and heightfield libraries assume upAxis = 1 + (that is, the y-axis is "up"). This class allows any of the 3 coordinates + to be "up". Make sure your choice of axis is consistent with your rendering + system. +

+ The heightfield heights are determined from the data type used for the + heightfieldData array. +

+ - unsigned char: height at a point is the uchar value at the + grid point, multipled by heightScale. uchar isn't recommended + because of its inability to deal with negative values, and + low resolution (8-bit). +

+ - short: height at a point is the short int value at that grid + point, multipled by heightScale. +

+ - float or dobule: height at a point is the value at that grid point. +

+ Whatever the caller specifies as minHeight and maxHeight will be honored. + The class will not inspect the heightfield to discover the actual minimum + or maximum heights. These values are used to determine the heightfield's + axis-aligned bounding box, multiplied by localScaling. +

+ For usage and testing see the TerrainDemo. + */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btHeightfieldTerrainShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHeightfieldTerrainShape(Pointer p) { super(p); } + + @NoOffset public static class Range extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Range(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Range(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public Range position(long position) { + return (Range)super.position(position); + } + @Override public Range getPointer(long i) { + return new Range((Pointer)this).offsetAddress(i); + } + + public Range() { super((Pointer)null); allocate(); } + private native void allocate(); + public Range(@Cast("btScalar") float min, @Cast("btScalar") float max) { super((Pointer)null); allocate(min, max); } + private native void allocate(@Cast("btScalar") float min, @Cast("btScalar") float max); + + public native @Cast("bool") boolean overlaps(@Const @ByRef Range other); + + public native @Cast("btScalar") float min(); public native Range min(float setter); + public native @Cast("btScalar") float max(); public native Range max(float setter); + } + + /** preferred constructors */ + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const FloatPointer heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const FloatPointer heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const FloatBuffer heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const FloatBuffer heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const float[] heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const float[] heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const DoublePointer heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const DoublePointer heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const DoubleBuffer heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const DoubleBuffer heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const double[] heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const double[] heightfieldData, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const ShortPointer heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, heightScale, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const ShortPointer heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const ShortBuffer heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, heightScale, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const ShortBuffer heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Const short[] heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, heightScale, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Const short[] heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Cast("const unsigned char*") BytePointer heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, heightScale, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Cast("const unsigned char*") BytePointer heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Cast("const unsigned char*") ByteBuffer heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, heightScale, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Cast("const unsigned char*") ByteBuffer heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + public btHeightfieldTerrainShape( + int heightStickWidth, int heightStickLength, + @Cast("const unsigned char*") byte[] heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, heightScale, minHeight, maxHeight, upAxis, flipQuadEdges); } + private native void allocate( + int heightStickWidth, int heightStickLength, + @Cast("const unsigned char*") byte[] heightfieldData, @Cast("btScalar") float heightScale, @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("bool") boolean flipQuadEdges); + + /** legacy constructor + /** + This constructor supports a range of heightfield + data types, and allows for a non-zero minimum height value. + heightScale is needed for any integer-based heightfield data types. +

+ This legacy constructor considers {@code PHY_FLOAT} to mean {@code btScalar}. + With {@code BT_USE_DOUBLE_PRECISION}, it will expect {@code heightfieldData} + to be double-precision. + */ + public btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, + @Const Pointer heightfieldData, @Cast("btScalar") float heightScale, + @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("PHY_ScalarType") int heightDataType, + @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, heightScale, minHeight, maxHeight, upAxis, heightDataType, flipQuadEdges); } + private native void allocate(int heightStickWidth, int heightStickLength, + @Const Pointer heightfieldData, @Cast("btScalar") float heightScale, + @Cast("btScalar") float minHeight, @Cast("btScalar") float maxHeight, + int upAxis, @Cast("PHY_ScalarType") int heightDataType, + @Cast("bool") boolean flipQuadEdges); + + /** legacy constructor + /** + The legacy constructor assumes the heightfield has a minimum height + of zero. Only unsigned char or btScalar data are supported. For legacy + compatibility reasons, heightScale is calculated as maxHeight / 65535 + (and is only used when useFloatData = false). + */ + public btHeightfieldTerrainShape(int heightStickWidth, int heightStickLength, @Const Pointer heightfieldData, @Cast("btScalar") float maxHeight, int upAxis, @Cast("bool") boolean useFloatData, @Cast("bool") boolean flipQuadEdges) { super((Pointer)null); allocate(heightStickWidth, heightStickLength, heightfieldData, maxHeight, upAxis, useFloatData, flipQuadEdges); } + private native void allocate(int heightStickWidth, int heightStickLength, @Const Pointer heightfieldData, @Cast("btScalar") float maxHeight, int upAxis, @Cast("bool") boolean useFloatData, @Cast("bool") boolean flipQuadEdges); + + public native void setUseDiamondSubdivision(@Cast("bool") boolean useDiamondSubdivision/*=true*/); + public native void setUseDiamondSubdivision(); + + /**could help compatibility with Ogre heightfields. See https://code.google.com/p/bullet/issues/detail?id=625 */ + public native void setUseZigzagSubdivision(@Cast("bool") boolean useZigzagSubdivision/*=true*/); + public native void setUseZigzagSubdivision(); + + public native void setFlipTriangleWinding(@Cast("bool") boolean flipTriangleWinding); + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + + public native @Const @ByRef btVector3 getLocalScaling(); + + public native void getVertex(int x, int y, @ByRef btVector3 vertex); + + public native void performRaycast(btTriangleCallback callback, @Const @ByRef btVector3 raySource, @Const @ByRef btVector3 rayTarget); + + public native void buildAccelerator(int chunkSize/*=16*/); + public native void buildAccelerator(); + public native void clearAccelerator(); + + public native int getUpAxis(); + //debugging + public native @Cast("const char*") BytePointer getName(); + + + public native void setUserValue3(@Cast("btScalar") float value); + public native @Cast("btScalar") float getUserValue3(); + public native btTriangleInfoMap getTriangleInfoMap(); + public native void setTriangleInfoMap(btTriangleInfoMap map); + public native @Cast("const unsigned char*") BytePointer getHeightfieldRawData(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiPenetrationDepthSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiPenetrationDepthSolver.java new file mode 100644 index 00000000000..8503c4d8300 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiPenetrationDepthSolver.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**MinkowskiPenetrationDepthSolver implements bruteforce penetration depth estimation. + * Implementation is based on sampling the depth using support mapping, and using GJK step to get the witness points. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMinkowskiPenetrationDepthSolver extends btConvexPenetrationDepthSolver { + static { Loader.load(); } + /** Default native constructor. */ + public btMinkowskiPenetrationDepthSolver() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMinkowskiPenetrationDepthSolver(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMinkowskiPenetrationDepthSolver(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMinkowskiPenetrationDepthSolver position(long position) { + return (btMinkowskiPenetrationDepthSolver)super.position(position); + } + @Override public btMinkowskiPenetrationDepthSolver getPointer(long i) { + return new btMinkowskiPenetrationDepthSolver((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") boolean calcPenDepth(@ByRef btSimplexSolverInterface simplexSolver, + @Const btConvexShape convexA, @Const btConvexShape convexB, + @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, + @ByRef btVector3 v, @ByRef btVector3 pa, @ByRef btVector3 pb, + btIDebugDraw debugDraw); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiSumShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiSumShape.java new file mode 100644 index 00000000000..2497f0cfd94 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiSumShape.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMinkowskiSumShape extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btMinkowskiSumShape() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMinkowskiSumShape(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprCollisionDescription.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprCollisionDescription.java new file mode 100644 index 00000000000..d53cfcd215e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprCollisionDescription.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +//#define MPR_AVERAGE_CONTACT_POSITIONS + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMprCollisionDescription extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMprCollisionDescription(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMprCollisionDescription(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMprCollisionDescription position(long position) { + return (btMprCollisionDescription)super.position(position); + } + @Override public btMprCollisionDescription getPointer(long i) { + return new btMprCollisionDescription((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_firstDir(); public native btMprCollisionDescription m_firstDir(btVector3 setter); + public native int m_maxGjkIterations(); public native btMprCollisionDescription m_maxGjkIterations(int setter); + public native @Cast("btScalar") float m_maximumDistanceSquared(); public native btMprCollisionDescription m_maximumDistanceSquared(float setter); + public native @Cast("btScalar") float m_gjkRelError2(); public native btMprCollisionDescription m_gjkRelError2(float setter); + + public btMprCollisionDescription() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprDistanceInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprDistanceInfo.java new file mode 100644 index 00000000000..2ae2299697c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprDistanceInfo.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMprDistanceInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMprDistanceInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMprDistanceInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMprDistanceInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMprDistanceInfo position(long position) { + return (btMprDistanceInfo)super.position(position); + } + @Override public btMprDistanceInfo getPointer(long i) { + return new btMprDistanceInfo((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_pointOnA(); public native btMprDistanceInfo m_pointOnA(btVector3 setter); + public native @ByRef btVector3 m_pointOnB(); public native btMprDistanceInfo m_pointOnB(btVector3 setter); + public native @ByRef btVector3 m_normalBtoA(); public native btMprDistanceInfo m_normalBtoA(btVector3 setter); + public native @Cast("btScalar") float m_distance(); public native btMprDistanceInfo m_distance(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprSimplex_t.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprSimplex_t.java new file mode 100644 index 00000000000..76dd441fc0b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprSimplex_t.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMprSimplex_t extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btMprSimplex_t() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMprSimplex_t(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprSupport_t.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprSupport_t.java new file mode 100644 index 00000000000..3150686c326 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMprSupport_t.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMprSupport_t extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btMprSupport_t() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMprSupport_t(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralContactClipping.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralContactClipping.java new file mode 100644 index 00000000000..33cc555ab5f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPolyhedralContactClipping.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// Clips a face to the back of a plane +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPolyhedralContactClipping extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btPolyhedralContactClipping() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPolyhedralContactClipping(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPolyhedralContactClipping(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btPolyhedralContactClipping position(long position) { + return (btPolyhedralContactClipping)super.position(position); + } + @Override public btPolyhedralContactClipping getPointer(long i) { + return new btPolyhedralContactClipping((Pointer)this).offsetAddress(i); + } + + public static native void clipHullAgainstHull(@Const @ByRef btVector3 separatingNormal1, @Const @ByRef btConvexPolyhedron hullA, @Const @ByRef btConvexPolyhedron hullB, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Cast("const btScalar") float minDist, @Cast("btScalar") float maxDist, @Cast("btVertexArray*") @ByRef btVector3Array worldVertsB1, @Cast("btVertexArray*") @ByRef btVector3Array worldVertsB2, @ByRef btDiscreteCollisionDetectorInterface.Result resultOut); + + public static native void clipFaceAgainstHull(@Const @ByRef btVector3 separatingNormal, @Const @ByRef btConvexPolyhedron hullA, @Const @ByRef btTransform transA, @Cast("btVertexArray*") @ByRef btVector3Array worldVertsB1, @Cast("btVertexArray*") @ByRef btVector3Array worldVertsB2, @Cast("const btScalar") float minDist, @Cast("btScalar") float maxDist, @ByRef btDiscreteCollisionDetectorInterface.Result resultOut); + + public static native @Cast("bool") boolean findSeparatingAxis(@Const @ByRef btConvexPolyhedron hullA, @Const @ByRef btConvexPolyhedron hullB, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @ByRef btVector3 sep, @ByRef btDiscreteCollisionDetectorInterface.Result resultOut); + + /**the clipFace method is used internally */ + public static native void clipFace(@Cast("const btVertexArray*") @ByRef btVector3Array pVtxIn, @Cast("btVertexArray*") @ByRef btVector3Array ppVtxOut, @Const @ByRef btVector3 planeNormalWS, @Cast("btScalar") float planeEqWS); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSdfCollisionShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSdfCollisionShape.java new file mode 100644 index 00000000000..277c8460b13 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSdfCollisionShape.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSdfCollisionShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSdfCollisionShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSdfCollisionShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSdfCollisionShape position(long position) { + return (btSdfCollisionShape)super.position(position); + } + @Override public btSdfCollisionShape getPointer(long i) { + return new btSdfCollisionShape((Pointer)this).offsetAddress(i); + } + + public btSdfCollisionShape() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean initializeSDF(@Cast("const char*") BytePointer sdfData, int sizeInBytes); + public native @Cast("bool") boolean initializeSDF(String sdfData, int sizeInBytes); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + public native void setLocalScaling(@Const @ByRef btVector3 scaling); + public native @Const @ByRef btVector3 getLocalScaling(); + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + public native @Cast("const char*") BytePointer getName(); + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); + + public native void processAllTriangles(btTriangleCallback callback, @Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax); + + public native @Cast("bool") boolean queryPoint(@Const @ByRef btVector3 ptInSDF, @Cast("btScalar*") @ByRef FloatPointer distOut, @ByRef btVector3 normal); + public native @Cast("bool") boolean queryPoint(@Const @ByRef btVector3 ptInSDF, @Cast("btScalar*") @ByRef FloatBuffer distOut, @ByRef btVector3 normal); + public native @Cast("bool") boolean queryPoint(@Const @ByRef btVector3 ptInSDF, @Cast("btScalar*") @ByRef float[] distOut, @ByRef btVector3 normal); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeHull.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeHull.java new file mode 100644 index 00000000000..6fee0d219f5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeHull.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btShapeHull class takes a btConvexShape, builds a simplified convex hull using btConvexHull and provides triangle indices and vertices. + * It can be useful for to simplify a complex convex object and for visualization of a non-polyhedral convex object. + * It approximates the convex hull using the supporting vertex of 42 directions. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btShapeHull extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btShapeHull(Pointer p) { super(p); } + + + public btShapeHull(@Const btConvexShape shape) { super((Pointer)null); allocate(shape); } + private native void allocate(@Const btConvexShape shape); + + public native @Cast("bool") boolean buildHull(@Cast("btScalar") float margin, int highres/*=0*/); + public native @Cast("bool") boolean buildHull(@Cast("btScalar") float margin); + + public native int numTriangles(); + public native int numVertices(); + public native int numIndices(); + + public native @Const btVector3 getVertexPointer(); + public native @Cast("const unsigned int*") IntPointer getIndexPointer(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubsimplexConvexCast.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubsimplexConvexCast.java new file mode 100644 index 00000000000..5ce5253f065 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSubsimplexConvexCast.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btSubsimplexConvexCast implements Gino van den Bergens' paper + * "Ray Casting against bteral Convex Objects with Application to Continuous Collision Detection" + * GJK based Ray Cast, optimized version + * Objects should not start in overlap, otherwise results are not defined. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSubsimplexConvexCast extends btConvexCast { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSubsimplexConvexCast(Pointer p) { super(p); } + + public btSubsimplexConvexCast(@Const btConvexShape shapeA, @Const btConvexShape shapeB, btSimplexSolverInterface simplexSolver) { super((Pointer)null); allocate(shapeA, shapeB, simplexSolver); } + private native void allocate(@Const btConvexShape shapeA, @Const btConvexShape shapeB, btSimplexSolverInterface simplexSolver); + + //virtual ~btSubsimplexConvexCast(); + /**SimsimplexConvexCast calculateTimeOfImpact calculates the time of impact+normal for the linear cast (sweep) between two moving objects. + * Precondition is that objects should not penetration/overlap at the start from the interval. Overlap can be tested using btGjkPairDetector. */ + public native @Cast("bool") boolean calcTimeOfImpact( + @Const @ByRef btTransform fromA, + @Const @ByRef btTransform toA, + @Const @ByRef btTransform fromB, + @Const @ByRef btTransform toB, + @ByRef CastResult result); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTetrahedronShapeEx.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTetrahedronShapeEx.java new file mode 100644 index 00000000000..250e04a4021 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTetrahedronShapeEx.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Helper class for tetrahedrons */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTetrahedronShapeEx extends btBU_Simplex1to4 { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTetrahedronShapeEx(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTetrahedronShapeEx(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTetrahedronShapeEx position(long position) { + return (btTetrahedronShapeEx)super.position(position); + } + @Override public btTetrahedronShapeEx getPointer(long i) { + return new btTetrahedronShapeEx((Pointer)this).offsetAddress(i); + } + + public btTetrahedronShapeEx() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void setVertices( + @Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, + @Const @ByRef btVector3 v2, @Const @ByRef btVector3 v3); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleConvexcastCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleConvexcastCallback.java new file mode 100644 index 00000000000..570a146c2dc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleConvexcastCallback.java @@ -0,0 +1,33 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleConvexcastCallback extends btTriangleCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleConvexcastCallback(Pointer p) { super(p); } + + public native @Const btConvexShape m_convexShape(); public native btTriangleConvexcastCallback m_convexShape(btConvexShape setter); + public native @ByRef btTransform m_convexShapeFrom(); public native btTriangleConvexcastCallback m_convexShapeFrom(btTransform setter); + public native @ByRef btTransform m_convexShapeTo(); public native btTriangleConvexcastCallback m_convexShapeTo(btTransform setter); + public native @ByRef btTransform m_triangleToWorld(); public native btTriangleConvexcastCallback m_triangleToWorld(btTransform setter); + public native @Cast("btScalar") float m_hitFraction(); public native btTriangleConvexcastCallback m_hitFraction(float setter); + public native @Cast("btScalar") float m_triangleCollisionMargin(); public native btTriangleConvexcastCallback m_triangleCollisionMargin(float setter); + public native @Cast("btScalar") float m_allowedPenetration(); public native btTriangleConvexcastCallback m_allowedPenetration(float setter); + + public native void processTriangle(btVector3 triangle, int partId, int triangleIndex); + + public native @Cast("btScalar") float reportHit(@Const @ByRef btVector3 hitNormalLocal, @Const @ByRef btVector3 hitPointLocal, @Cast("btScalar") float hitFraction, int partId, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleRaycastCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleRaycastCallback.java new file mode 100644 index 00000000000..b3e034deb04 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleRaycastCallback.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleRaycastCallback extends btTriangleCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleRaycastCallback(Pointer p) { super(p); } + + //input + public native @ByRef btVector3 m_from(); public native btTriangleRaycastCallback m_from(btVector3 setter); + public native @ByRef btVector3 m_to(); public native btTriangleRaycastCallback m_to(btVector3 setter); + + //@BP Mod - allow backface filtering and unflipped normals + /** enum btTriangleRaycastCallback::EFlags */ + public static final int + kF_None = 0, + kF_FilterBackfaces = 1 << 0, + kF_KeepUnflippedNormal = 1 << 1, // Prevents returned face normal getting flipped when a ray hits a back-facing triangle + /**SubSimplexConvexCastRaytest is the default, even if kF_None is set. */ + kF_UseSubSimplexConvexCastRaytest = 1 << 2, // Uses an approximate but faster ray versus convex intersection algorithm + kF_UseGjkConvexCastRaytest = 1 << 3, + kF_DisableHeightfieldAccelerator = 1 << 4, //don't use the heightfield raycast accelerator. See https://github.com/bulletphysics/bullet3/pull/2062 + kF_Terminator = 0xFFFFFFFF; + public native @Cast("unsigned int") int m_flags(); public native btTriangleRaycastCallback m_flags(int setter); + + public native @Cast("btScalar") float m_hitFraction(); public native btTriangleRaycastCallback m_hitFraction(float setter); + + public native void processTriangle(btVector3 triangle, int partId, int triangleIndex); + + public native @Cast("btScalar") float reportHit(@Const @ByRef btVector3 hitNormalLocal, @Cast("btScalar") float hitFraction, int partId, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleShape.java new file mode 100644 index 00000000000..68bbfa9096c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleShape.java @@ -0,0 +1,73 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangleShape extends btPolyhedralConvexShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangleShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangleShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTriangleShape position(long position) { + return (btTriangleShape)super.position(position); + } + @Override public btTriangleShape getPointer(long i) { + return new btTriangleShape((Pointer)this).offsetAddress(i); + } + + + public native @ByRef btVector3 m_vertices1(int i); public native btTriangleShape m_vertices1(int i, btVector3 setter); + @MemberGetter public native btVector3 m_vertices1(); + + public native int getNumVertices(); + + public native @ByRef btVector3 getVertexPtr(int index); + public native void getVertex(int index, @ByRef btVector3 vert); + + public native int getNumEdges(); + + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 dir); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public btTriangleShape() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btTriangleShape(@Const @ByRef btVector3 p0, @Const @ByRef btVector3 p1, @Const @ByRef btVector3 p2) { super((Pointer)null); allocate(p0, p1, p2); } + private native void allocate(@Const @ByRef btVector3 p0, @Const @ByRef btVector3 p1, @Const @ByRef btVector3 p2); + + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + + public native int getNumPlanes(); + + public native void calcNormal(@ByRef btVector3 normal); + + public native void getPlaneEquation(int i, @ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumPreferredPenetrationDirections(); + + public native void getPreferredPenetrationDirection(int index, @ByRef btVector3 penetrationVector); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index 9065607a1ea..c4b0ca9f004 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -1070,6 +1070,558 @@ EPA Copyright (c) Ricardo Padrela 2006 // #endif // BT_GJP_EPA_PENETRATION_DEPTH_H +// Parsed from BulletCollision/NarrowPhaseCollision/btConvexCast.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_CAST_H +// #define BT_CONVEX_CAST_H + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btScalar.h" +// Targeting ../BulletCollision/btMinkowskiSumShape.java + + +// #include "LinearMath/btIDebugDraw.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +public static final int MAX_CONVEX_CAST_ITERATIONS = 32; +public static native @MemberGetter double MAX_CONVEX_CAST_EPSILON(); +public static final double MAX_CONVEX_CAST_EPSILON = MAX_CONVEX_CAST_EPSILON(); +// Targeting ../BulletCollision/btConvexCast.java + + + +// #endif //BT_CONVEX_CAST_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONTINUOUS_COLLISION_CONVEX_CAST_H +// #define BT_CONTINUOUS_COLLISION_CONVEX_CAST_H + +// #include "btConvexCast.h" +// #include "btSimplexSolverInterface.h" +// Targeting ../BulletCollision/btContinuousConvexCollision.java + + + +// #endif //BT_CONTINUOUS_COLLISION_CONVEX_CAST_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GJK_CONVEX_CAST_H +// #define BT_GJK_CONVEX_CAST_H + +// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" + +// #include "LinearMath/btVector3.h" +// #include "btConvexCast.h" +// #include "btSimplexSolverInterface.h" +// Targeting ../BulletCollision/btGjkConvexCast.java + + + +// #endif //BT_GJK_CONVEX_CAST_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btGjkEpa2.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the +use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not +claim that you wrote the original software. If you use this software in a +product, an acknowledgment in the product documentation would be appreciated +but is not required. +2. Altered source versions must be plainly marked as such, and must not be +misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +GJK-EPA collision solver by Nathanael Presson, 2008 +*/ +// #ifndef BT_GJK_EPA2_H +// #define BT_GJK_EPA2_H + +// #include "BulletCollision/CollisionShapes/btConvexShape.h" +// Targeting ../BulletCollision/btGjkEpaSolver2.java + + + +// #endif //BT_GJK_EPA2_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btGjkEpa3.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2014 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the +use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not +claim that you wrote the original software. If you use this software in a +product, an acknowledgment in the product documentation would be appreciated +but is not required. +2. Altered source versions must be plainly marked as such, and must not be +misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +Initial GJK-EPA collision solver by Nathanael Presson, 2008 +Improvements and refactoring by Erwin Coumans, 2008-2014 +*/ +// #ifndef BT_GJK_EPA3_H +// #define BT_GJK_EPA3_H + +// #include "LinearMath/btTransform.h" +// #include "btGjkCollisionDescription.h" +// Targeting ../BulletCollision/btGjkEpaSolver3.java + + + +// #if defined(DEBUG) || defined(_DEBUG) +// #include //for debug printf +// #ifdef __SPU__ +// #endif //__SPU__ +// #endif + +// Config + +/* GJK */ +public static final int GJK_MAX_ITERATIONS = 128; +public static final double GJK_ACCURARY = ((float)0.0001); +public static final double GJK_MIN_DISTANCE = ((float)0.0001); +public static final double GJK_DUPLICATED_EPS = ((float)0.0001); +public static final double GJK_SIMPLEX2_EPS = ((float)0.0); +public static final double GJK_SIMPLEX3_EPS = ((float)0.0); +public static final double GJK_SIMPLEX4_EPS = ((float)0.0); + +/* EPA */ +public static final int EPA_MAX_VERTICES = 64; +public static final int EPA_MAX_FACES = (EPA_MAX_VERTICES * 2); +public static final int EPA_MAX_ITERATIONS = 255; +public static final double EPA_ACCURACY = ((float)0.0001); +public static final double EPA_FALLBACK = (10 * EPA_ACCURACY); +public static final double EPA_PLANE_EPS = ((float)0.00001); +public static final double EPA_INSIDE_EPS = ((float)0.01); + +// Shorthands + +// MinkowskiDiff + +/** enum eGjkStatus */ +public static final int + eGjkValid = 0, + eGjkInside = 1, + eGjkFailed = 2; + +// GJK + +/** enum eEpaStatus */ +public static final int + eEpaValid = 0, + eEpaTouching = 1, + eEpaDegenerated = 2, + eEpaNonConvex = 3, + eEpaInvalidHull = 4, + eEpaOutOfFaces = 5, + eEpaOutOfVertices = 6, + eEpaAccuraryReached = 7, + eEpaFallBack = 8, + eEpaFailed = 9; + +// EPA + +// +// Api +// + +// + +// #if 0 +// #endif + +/* Symbols cleanup */ + +// #undef GJK_MAX_ITERATIONS +// #undef GJK_ACCURARY +// #undef GJK_MIN_DISTANCE +// #undef GJK_DUPLICATED_EPS +// #undef GJK_SIMPLEX2_EPS +// #undef GJK_SIMPLEX3_EPS +// #undef GJK_SIMPLEX4_EPS + +// #undef EPA_MAX_VERTICES +// #undef EPA_MAX_FACES +// #undef EPA_MAX_ITERATIONS +// #undef EPA_ACCURACY +// #undef EPA_FALLBACK +// #undef EPA_PLANE_EPS +// #undef EPA_INSIDE_EPS + +// #endif //BT_GJK_EPA3_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GJK_PAIR_DETECTOR_H +// #define BT_GJK_PAIR_DETECTOR_H + +// #include "btDiscreteCollisionDetectorInterface.h" +// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" +// #include "btSimplexSolverInterface.h" +// Targeting ../BulletCollision/btGjkPairDetector.java + + + +// #endif //BT_GJK_PAIR_DETECTOR_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H +// #define BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H + +// #include "btConvexPenetrationDepthSolver.h" +// Targeting ../BulletCollision/btMinkowskiPenetrationDepthSolver.java + + + +// #endif //BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btMprPenetration.h + + +/*** + * --------------------------------- + * Copyright (c)2012 Daniel Fiser + * + * This file was ported from mpr.c file, part of libccd. + * The Minkoski Portal Refinement implementation was ported + * to OpenCL by Erwin Coumans for the Bullet 3 Physics library. + * The original MPR idea and implementation is by Gary Snethen + * in XenoCollide, see http://github.com/erwincoumans/xenocollide + * + * Distributed under the OSI-approved BSD License (the "License"); + * see . + * This software is distributed WITHOUT ANY WARRANTY; without even the + * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the License for more information. + */ + +/**2014 Oct, Erwin Coumans, Use templates to avoid void* casts */ + +// #ifndef BT_MPR_PENETRATION_H +// #define BT_MPR_PENETRATION_H + +// #define BT_DEBUG_MPR1 + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btMprCollisionDescription.java + + +// Targeting ../BulletCollision/btMprDistanceInfo.java + + + +// #ifdef __cplusplus +// #define BT_MPR_SQRT sqrtf +// #else +// #define BT_MPR_SQRT sqrt +// #endif +// #define BT_MPR_FMIN(x, y) ((x) < (y) ? (x) : (y)) +// #define BT_MPR_FABS fabs + +public static final double BT_MPR_TOLERANCE = 1E-6f; +public static final int BT_MPR_MAX_ITERATIONS = 1000; +// Targeting ../BulletCollision/_btMprSupport_t.java + + +// Targeting ../BulletCollision/btMprSupport_t.java + + +// Targeting ../BulletCollision/_btMprSimplex_t.java + + +// Targeting ../BulletCollision/btMprSimplex_t.java + + + +public static native btMprSupport_t btMprSimplexPointW(btMprSimplex_t s, int idx); + +public static native void btMprSimplexSetSize(btMprSimplex_t s, int size); + +// #ifdef DEBUG_MPR +// #endif //DEBUG_MPR + +public static native int btMprSimplexSize(@Const btMprSimplex_t s); + +public static native @Const btMprSupport_t btMprSimplexPoint(@Const btMprSimplex_t s, int idx); + +public static native void btMprSupportCopy(btMprSupport_t d, @Const btMprSupport_t s); + +public static native void btMprSimplexSet(btMprSimplex_t s, @Cast("size_t") long pos, @Const btMprSupport_t a); + +public static native void btMprSimplexSwap(btMprSimplex_t s, @Cast("size_t") long pos1, @Cast("size_t") long pos2); + +public static native int btMprIsZero(float val); + +public static native int btMprEq(float _a, float _b); + +public static native int btMprVec3Eq(@Const btVector3 a, @Const btVector3 b); + +public static native void btMprVec3Set(btVector3 v, float x, float y, float z); + +public static native void btMprVec3Add(btVector3 v, @Const btVector3 w); + +public static native void btMprVec3Copy(btVector3 v, @Const btVector3 w); + +public static native void btMprVec3Scale(btVector3 d, float k); + +public static native float btMprVec3Dot(@Const btVector3 a, @Const btVector3 b); + +public static native float btMprVec3Len2(@Const btVector3 v); + +public static native void btMprVec3Normalize(btVector3 d); + +public static native void btMprVec3Cross(btVector3 d, @Const btVector3 a, @Const btVector3 b); + +public static native void btMprVec3Sub2(btVector3 d, @Const btVector3 v, @Const btVector3 w); + +public static native void btPortalDir(@Const btMprSimplex_t portal, btVector3 dir); + +public static native int portalEncapsulesOrigin(@Const btMprSimplex_t portal, + @Const btVector3 dir); + +public static native int portalReachTolerance(@Const btMprSimplex_t portal, + @Const btMprSupport_t v4, + @Const btVector3 dir); + +public static native int portalCanEncapsuleOrigin(@Const btMprSimplex_t portal, + @Const btMprSupport_t v4, + @Const btVector3 dir); + +public static native void btExpandPortal(btMprSimplex_t portal, + @Const btMprSupport_t v4); + +public static native void btFindPos(@Const btMprSimplex_t portal, btVector3 pos); + +public static native float btMprVec3Dist2(@Const btVector3 a, @Const btVector3 b); + +public static native float _btMprVec3PointSegmentDist2(@Const btVector3 P, + @Const btVector3 x0, + @Const btVector3 b, + btVector3 witness); + +public static native float btMprVec3PointTriDist2(@Const btVector3 P, + @Const btVector3 x0, @Const btVector3 B, + @Const btVector3 C, + btVector3 witness); + +public static native void btFindPenetrTouch(btMprSimplex_t portal, FloatPointer depth, btVector3 dir, btVector3 pos); +public static native void btFindPenetrTouch(btMprSimplex_t portal, FloatBuffer depth, btVector3 dir, btVector3 pos); +public static native void btFindPenetrTouch(btMprSimplex_t portal, float[] depth, btVector3 dir, btVector3 pos); + +public static native void btFindPenetrSegment(btMprSimplex_t portal, + FloatPointer depth, btVector3 dir, btVector3 pos); +public static native void btFindPenetrSegment(btMprSimplex_t portal, + FloatBuffer depth, btVector3 dir, btVector3 pos); +public static native void btFindPenetrSegment(btMprSimplex_t portal, + float[] depth, btVector3 dir, btVector3 pos); + +// #endif //BT_MPR_PENETRATION_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef BT_POLYHEDRAL_CONTACT_CLIPPING_H +// #define BT_POLYHEDRAL_CONTACT_CLIPPING_H + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btTransform.h" +// #include "btDiscreteCollisionDetectorInterface.h" +// Targeting ../BulletCollision/btPolyhedralContactClipping.java + + + +// #endif // BT_POLYHEDRAL_CONTACT_CLIPPING_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SUBSIMPLEX_CONVEX_CAST_H +// #define BT_SUBSIMPLEX_CONVEX_CAST_H + +// #include "btConvexCast.h" +// #include "btSimplexSolverInterface.h" +// Targeting ../BulletCollision/btSubsimplexConvexCast.java + + + +// #endif //BT_SUBSIMPLEX_CONVEX_CAST_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btRaycastCallback.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_RAYCAST_TRI_CALLBACK_H +// #define BT_RAYCAST_TRI_CALLBACK_H + +// #include "BulletCollision/CollisionShapes/btTriangleCallback.h" +// #include "LinearMath/btTransform.h" +// Targeting ../BulletCollision/btTriangleRaycastCallback.java + + +// Targeting ../BulletCollision/btTriangleConvexcastCallback.java + + + +// #endif //BT_RAYCAST_TRI_CALLBACK_H + + // Parsed from BulletCollision/CollisionDispatch/btCollisionConfiguration.h /* @@ -1368,17 +1920,146 @@ EPA Copyright (c) Ricardo Padrela 2006 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H -// #define __BT_ACTIVATING_COLLISION_ALGORITHM_H +// #ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H +// #define __BT_ACTIVATING_COLLISION_ALGORITHM_H + +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// Targeting ../BulletCollision/btActivatingCollisionAlgorithm.java + + +// #endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H + + +// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H + +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "btCollisionDispatcher.h" +// Targeting ../BulletCollision/btSphereSphereCollisionAlgorithm.java + + + +// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H + + +// Parsed from BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_DEFAULT_COLLISION_CONFIGURATION +// #define BT_DEFAULT_COLLISION_CONFIGURATION + +// #include "btCollisionConfiguration.h" +// Targeting ../BulletCollision/btDefaultCollisionConstructionInfo.java + + +// Targeting ../BulletCollision/btDefaultCollisionConfiguration.java + + + +// #endif //BT_DEFAULT_COLLISION_CONFIGURATION + + +// Parsed from BulletCollision/CollisionDispatch/btSimulationIslandManager.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMULATION_ISLAND_MANAGER_H +// #define BT_SIMULATION_ISLAND_MANAGER_H + +// #include "BulletCollision/CollisionDispatch/btUnionFind.h" +// #include "btCollisionCreateFunc.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btCollisionObject.h" +// Targeting ../BulletCollision/btSimulationIslandManager.java + + + +// #endif //BT_SIMULATION_ISLAND_MANAGER_H + + +// Parsed from BulletCollision/CollisionDispatch/btUnionFind.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_UNION_FIND_H +// #define BT_UNION_FIND_H + +// #include "LinearMath/btAlignedObjectArray.h" + +public static final int USE_PATH_COMPRESSION = 1; + +/**see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406 */ +public static final int STATIC_SIMULATION_ISLAND_OPTIMIZATION = 1; +// Targeting ../BulletCollision/btElement.java + -// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" -// Targeting ../BulletCollision/btActivatingCollisionAlgorithm.java +// Targeting ../BulletCollision/btUnionFind.java -// #endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H +// #endif //BT_UNION_FIND_H -// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h + +// Parsed from BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h /* Bullet Continuous Collision Detection and Physics Library @@ -1395,21 +2076,19 @@ EPA Copyright (c) Ricardo Padrela 2006 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H -// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #ifndef BT_COLLISION_DISPATCHER_MT_H +// #define BT_COLLISION_DISPATCHER_MT_H -// #include "btActivatingCollisionAlgorithm.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" -// #include "btCollisionDispatcher.h" -// Targeting ../BulletCollision/btSphereSphereCollisionAlgorithm.java +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +// #include "LinearMath/btThreads.h" +// Targeting ../BulletCollision/btCollisionDispatcherMt.java -// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #endif //BT_COLLISION_DISPATCHER_MT_H -// Parsed from BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h +// Parsed from BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -1426,21 +2105,21 @@ EPA Copyright (c) Ricardo Padrela 2006 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_DEFAULT_COLLISION_CONFIGURATION -// #define BT_DEFAULT_COLLISION_CONFIGURATION - -// #include "btCollisionConfiguration.h" -// Targeting ../BulletCollision/btDefaultCollisionConstructionInfo.java - +// #ifndef BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H +// #define BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H -// Targeting ../BulletCollision/btDefaultCollisionConfiguration.java +// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// Targeting ../BulletCollision/btBox2dBox2dCollisionAlgorithm.java -// #endif //BT_DEFAULT_COLLISION_CONFIGURATION +// #endif //BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btSimulationIslandManager.h +// Parsed from BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -1457,21 +2136,25 @@ EPA Copyright (c) Ricardo Padrela 2006 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SIMULATION_ISLAND_MANAGER_H -// #define BT_SIMULATION_ISLAND_MANAGER_H +// #ifndef BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H +// #define BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H -// #include "BulletCollision/CollisionDispatch/btUnionFind.h" -// #include "btCollisionCreateFunc.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #include "btCollisionObject.h" -// Targeting ../BulletCollision/btSimulationIslandManager.java +// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +// #include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil +// Targeting ../BulletCollision/btConvex2dConvex2dAlgorithm.java -// #endif //BT_SIMULATION_ISLAND_MANAGER_H +// #endif //BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btUnionFind.h +// Parsed from BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -1488,52 +2171,58 @@ EPA Copyright (c) Ricardo Padrela 2006 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_UNION_FIND_H -// #define BT_UNION_FIND_H +// #ifndef BT_EMPTY_ALGORITH +// #define BT_EMPTY_ALGORITH +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// #include "btCollisionCreateFunc.h" +// #include "btCollisionDispatcher.h" -// #include "LinearMath/btAlignedObjectArray.h" +// #define ATTRIBUTE_ALIGNED(a) +// Targeting ../BulletCollision/btEmptyAlgorithm.java -public static final int USE_PATH_COMPRESSION = 1; -/**see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406 */ -public static final int STATIC_SIMULATION_ISLAND_OPTIMIZATION = 1; -// Targeting ../BulletCollision/btElement.java +// #endif //BT_EMPTY_ALGORITH -// Targeting ../BulletCollision/btUnionFind.java +// Parsed from BulletCollision/CollisionDispatch/btInternalEdgeUtility.h -// #endif //BT_UNION_FIND_H +// #ifndef BT_INTERNAL_EDGE_UTILITY_H +// #define BT_INTERNAL_EDGE_UTILITY_H +// #include "LinearMath/btHashMap.h" +// #include "LinearMath/btVector3.h" -// Parsed from BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h +// #include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +/**The btInternalEdgeUtility helps to avoid or reduce artifacts due to wrong collision normals caused by internal edges. + * See also http://code.google.com/p/bullet/issues/detail?id=27 */ -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: +/** enum btInternalEdgeAdjustFlags */ +public static final int + BT_TRIANGLE_CONVEX_BACKFACE_MODE = 1, + BT_TRIANGLE_CONCAVE_DOUBLE_SIDED = 2, //double sided options are experimental, single sided is recommended + BT_TRIANGLE_CONVEX_DOUBLE_SIDED = 4; -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ +/**Call btGenerateInternalEdgeInfo to create triangle info, store in the shape 'userInfo' */ +public static native void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape trimeshShape, btTriangleInfoMap triangleInfoMap); -// #ifndef BT_COLLISION_DISPATCHER_MT_H -// #define BT_COLLISION_DISPATCHER_MT_H +public static native void btGenerateInternalEdgeInfo(btHeightfieldTerrainShape trimeshShape, btTriangleInfoMap triangleInfoMap); -// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" -// #include "LinearMath/btThreads.h" -// Targeting ../BulletCollision/btCollisionDispatcherMt.java +/**Call the btFixMeshNormal to adjust the collision normal, using the triangle info map (generated using btGenerateInternalEdgeInfo) + * If this info map is missing, or the triangle is not store in this map, nothing will be done */ +public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags/*=0*/); +public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0); +/**Enable the BT_INTERNAL_EDGE_DEBUG_DRAW define and call btSetDebugDrawer, to get visual info to see if the internal edge utility works properly. + * If the utility doesn't work properly, you might have to adjust the threshold values in btTriangleInfoMap */ +//#define BT_INTERNAL_EDGE_DEBUG_DRAW +// #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW +// #endif //BT_INTERNAL_EDGE_DEBUG_DRAW -// #endif //BT_COLLISION_DISPATCHER_MT_H +// #endif //BT_INTERNAL_EDGE_UTILITY_H // Parsed from BulletCollision/CollisionShapes/btCollisionShape.h @@ -2567,4 +3256,240 @@ EPA Copyright (c) Ricardo Padrela 2006 // #endif //BT_UNIFORM_SCALING_SHAPE_H +// Parsed from BulletCollision/CollisionShapes/btBox2dShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBB_BOX_2D_SHAPE_H +// #define BT_OBB_BOX_2D_SHAPE_H + +// #include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" +// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMinMax.h" +// Targeting ../BulletCollision/btBox2dShape.java + + + +// #endif //BT_OBB_BOX_2D_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConvex2dShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONVEX_2D_SHAPE_H +// #define BT_CONVEX_2D_SHAPE_H + +// #include "BulletCollision/CollisionShapes/btConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btConvex2dShape.java + + + +// #endif //BT_CONVEX_2D_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_HEIGHTFIELD_TERRAIN_SHAPE_H +// #define BT_HEIGHTFIELD_TERRAIN_SHAPE_H + +// #include "btConcaveShape.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btHeightfieldTerrainShape.java + + + +// #endif //BT_HEIGHTFIELD_TERRAIN_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBB_TRIANGLE_MINKOWSKI_H +// #define BT_OBB_TRIANGLE_MINKOWSKI_H + +// #include "btConvexShape.h" +// #include "btBoxShape.h" +// Targeting ../BulletCollision/btTriangleShape.java + + + +// #endif //BT_OBB_TRIANGLE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btSdfCollisionShape.h + +// #ifndef BT_SDF_COLLISION_SHAPE_H +// #define BT_SDF_COLLISION_SHAPE_H + +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btSdfCollisionShape.java + + + +// #endif //BT_SDF_COLLISION_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btShapeHull.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**btShapeHull implemented by John McCutchan. */ + +// #ifndef BT_SHAPE_HULL_H +// #define BT_SHAPE_HULL_H + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletCollision/CollisionShapes/btConvexShape.h" +// Targeting ../BulletCollision/btShapeHull.java + + + +// #endif //BT_SHAPE_HULL_H + + +// Parsed from BulletCollision/Gimpact/btGImpactShape.h + +/** \file btGImpactShape.h +@author Francisco Len N�jera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef GIMPACT_SHAPE_H +// #define GIMPACT_SHAPE_H + +// #include "BulletCollision/CollisionShapes/btCollisionShape.h" +// #include "BulletCollision/CollisionShapes/btTriangleShape.h" +// #include "BulletCollision/CollisionShapes/btStridingMeshInterface.h" +// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" +// #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" +// #include "BulletCollision/CollisionShapes/btConcaveShape.h" +// #include "BulletCollision/CollisionShapes/btTetrahedronShape.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "LinearMath/btAlignedObjectArray.h" + +// #include "btGImpactQuantizedBvh.h" // box tree class + +/** declare Quantized trees, (you can change to float based trees) */ + +/** enum eGIMPACT_SHAPE_TYPE */ +public static final int + CONST_GIMPACT_COMPOUND_SHAPE = 0, + CONST_GIMPACT_TRIMESH_SHAPE_PART = 1, + CONST_GIMPACT_TRIMESH_SHAPE = 2; +// Targeting ../BulletCollision/btTetrahedronShapeEx.java + + +// Targeting ../BulletCollision/btGImpactShapeInterface.java + + +// Targeting ../BulletCollision/btGImpactCompoundShape.java + + +// Targeting ../BulletCollision/btGImpactMeshShapePart.java + + +// Targeting ../BulletCollision/btGImpactMeshShape.java + + +// Targeting ../BulletCollision/btGImpactMeshShapeData.java + + + + + +// #endif //GIMPACT_MESH_SHAPE_H + + } From bcbde6c50cc9a6732d7541dad4662c9440e4f06b Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 28 Feb 2022 23:59:06 +0800 Subject: [PATCH 45/81] Map extra headers from bullet's BulletDynamics Referenced from bullet's examples. --- .../bullet/presets/BulletDynamics.java | 19 +++++++++++++++++++ .../bytedeco/bullet/presets/LinearMath.java | 15 +++++++++++++++ 2 files changed, 34 insertions(+) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index 33889601265..90d0e2e7fa9 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -66,6 +66,7 @@ "BulletDynamics/ConstraintSolver/btTypedConstraint.h", "BulletDynamics/ConstraintSolver/btBatchedConstraints.h", "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h", + "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h", "BulletDynamics/Vehicle/btVehicleRaycaster.h", "BulletDynamics/Vehicle/btWheelInfo.h", "BulletDynamics/Vehicle/btRaycastVehicle.h", @@ -76,6 +77,19 @@ "BulletDynamics/Featherstone/btMultiBodyConstraint.h", "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h", "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h", + "BulletDynamics/Featherstone/btMultiBodySolverConstraint.h", + "BulletDynamics/Featherstone/btMultiBodyFixedConstraint.h", + "BulletDynamics/Featherstone/btMultiBodyGearConstraint.h", + "BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.h", + "BulletDynamics/Featherstone/btMultiBodyJointMotor.h", + "BulletDynamics/Featherstone/btMultiBodyPoint2Point.h", + "BulletDynamics/Featherstone/btMultiBodySliderConstraint.h", + "BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h", + "BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h", + "BulletDynamics/MLCPSolvers/btDantzigSolver.h", + "BulletDynamics/MLCPSolvers/btLemkeSolver.h", + "BulletDynamics/MLCPSolvers/btMLCPSolver.h", + "BulletDynamics/MLCPSolvers/btSolveProjectedGaussSeidel.h", }, link = "BulletDynamics@.3.20" ) @@ -114,11 +128,16 @@ public void map(InfoMap infoMap) { ).define(true)) .put(new Info("btAlignedObjectArray").pointerTypes("btRigidBodyArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btMultiBodySolverConstraintArray")) .put(new Info( "DeformableBodyInplaceSolverIslandCallback", "InplaceSolverIslandCallback", "MultiBodyInplaceSolverIslandCallback", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btBatchedConstraints::m_batches", "btBatchedConstraints::m_phases", "btConeTwistConstraint::solveConstraintObsolete", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index df702a28d27..26707a5d440 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -63,6 +63,7 @@ "LinearMath/btGeometryUtil.h", "LinearMath/btMinMax.h", "LinearMath/btTransformUtil.h", + "LinearMath/btMatrixX.h", }, link = "LinearMath@.3.20" ) @@ -88,6 +89,7 @@ public void map(InfoMap infoMap) { "(defined (__APPLE__) && (!defined (BT_USE_DOUBLE_PRECISION)))", "(defined(BT_USE_SSE_IN_API) && defined(BT_USE_SSE)) || defined(BT_USE_NEON)", "BT_DEBUG_MEMORY_ALLOCATIONS", + "BT_DEBUG_OSTREAM", "BT_USE_DOUBLE_PRECISION", "BT_USE_NEON", "BT_USE_SSE", @@ -111,6 +113,8 @@ public void map(InfoMap infoMap) { .put(new Info("btAlignedObjectArray").pointerTypes("btCharArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btIntArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btUIntArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btScalarArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDoubleArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btScalarArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btMatrix3x3Array")) .put(new Info("btAlignedObjectArray").pointerTypes("btQuaternionArray")) @@ -122,7 +126,14 @@ public void map(InfoMap infoMap) { .put(new Info("btAlignedObjectArray").pointerTypes("btConvexHullComputerEdgeArray")) .put(new Info("btConvexHullComputer::Edge").pointerTypes("btConvexHullComputer.Edge")) .put(new Info("btHashMap").pointerTypes("btHashMap_btHashPtr_voidPointer")) + .put(new Info("btAlignedObjectArray >").javaNames("btIntArrayArray")) .put(new Info("int4").pointerTypes("Int4")) + .put(new Info("btVectorX").pointerTypes("btVectorXf")) + .put(new Info("btVectorX").pointerTypes("btVectorXd")) + .put(new Info("btMatrixX").pointerTypes("btMatrixXf")) + .put(new Info("btMatrixX").pointerTypes("btMatrixXd")) + .put(new Info("btVectorXu").cppText("#define btVectorXu btVectorXf")) + .put(new Info("btMatrixXu").cppText("#define btMatrixXu btMatrixXf")) .put(new Info("btAlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) @@ -136,6 +147,10 @@ public void map(InfoMap infoMap) { "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", From 7fa9e8bf7c1ad95a1fe3ff0100a385669e031e0f Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 1 Mar 2022 00:10:39 +0800 Subject: [PATCH 46/81] Update generated code of bullet preset See parent commit. --- .../BulletDynamics/btDantzigSolver.java | 38 ++ .../bullet/BulletDynamics/btLemkeSolver.java | 45 ++ .../bullet/BulletDynamics/btMLCPSolver.java | 33 ++ .../BulletDynamics/btMLCPSolverInterface.java | 24 + .../btMultiBodyFixedConstraint.java | 55 +++ .../btMultiBodyGearConstraint.java | 59 +++ .../btMultiBodyJointLimitConstraint.java | 41 ++ .../BulletDynamics/btMultiBodyJointMotor.java | 47 ++ .../btMultiBodyMLCPConstraintSolver.java | 46 ++ .../btMultiBodyPoint2Point.java | 46 ++ .../btMultiBodySliderConstraint.java | 59 +++ .../btMultiBodySolverConstraint.java | 84 ++++ .../btMultiBodySolverConstraintArray.java | 90 ++++ .../btMultiBodySphericalJointMotor.java | 60 +++ .../btNNCGConstraintSolver.java | 40 ++ .../btSolveProjectedGaussSeidel.java | 42 ++ .../bullet/LinearMath/btDoubleArray.java | 86 ++++ .../bullet/LinearMath/btIntArrayArray.java | 86 ++++ .../bullet/LinearMath/btIntSortPredicate.java | 37 ++ .../bullet/LinearMath/btMatrixXd.java | 92 ++++ .../bullet/LinearMath/btMatrixXf.java | 99 ++++ .../bullet/LinearMath/btScalarArray.java | 24 +- .../bullet/LinearMath/btVectorXd.java | 40 ++ .../bullet/LinearMath/btVectorXf.java | 40 ++ .../bullet/global/BulletDynamics.java | 423 ++++++++++++++++++ .../bytedeco/bullet/global/LinearMath.java | 63 +++ 26 files changed, 1787 insertions(+), 12 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDantzigSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btLemkeSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolverInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFixedConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyGearConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointLimitConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointMotor.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyMLCPConstraintSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyPoint2Point.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySliderConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySolverConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySolverConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySphericalJointMotor.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btNNCGConstraintSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolveProjectedGaussSeidel.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDoubleArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntSortPredicate.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrixXd.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrixXf.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVectorXd.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVectorXf.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDantzigSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDantzigSolver.java new file mode 100644 index 00000000000..0ba799c433d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDantzigSolver.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btDantzigSolver extends btMLCPSolverInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDantzigSolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDantzigSolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDantzigSolver position(long position) { + return (btDantzigSolver)super.position(position); + } + @Override public btDantzigSolver getPointer(long i) { + return new btDantzigSolver((Pointer)this).offsetAddress(i); + } + + public btDantzigSolver() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean solveMLCP(@Const @ByRef btMatrixXf A, @Const @ByRef btVectorXf b, @ByRef btVectorXf x, @Const @ByRef btVectorXf lo, @Const @ByRef btVectorXf hi, @Const @ByRef btIntArray limitDependency, int numIterations, @Cast("bool") boolean useSparsity/*=true*/); + public native @Cast("bool") boolean solveMLCP(@Const @ByRef btMatrixXf A, @Const @ByRef btVectorXf b, @ByRef btVectorXf x, @Const @ByRef btVectorXf lo, @Const @ByRef btVectorXf hi, @Const @ByRef btIntArray limitDependency, int numIterations); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btLemkeSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btLemkeSolver.java new file mode 100644 index 00000000000..e3069be3b63 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btLemkeSolver.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**The btLemkeSolver is based on "Fast Implementation of Lemke’s Algorithm for Rigid Body Contact Simulation (John E. Lloyd) " + * It is a slower but more accurate solver. Increase the m_maxLoops for better convergence, at the cost of more CPU time. + * The original implementation of the btLemkeAlgorithm was done by Kilian Grundl from the MBSim team */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btLemkeSolver extends btMLCPSolverInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btLemkeSolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btLemkeSolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btLemkeSolver position(long position) { + return (btLemkeSolver)super.position(position); + } + @Override public btLemkeSolver getPointer(long i) { + return new btLemkeSolver((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_maxValue(); public native btLemkeSolver m_maxValue(float setter); + public native int m_debugLevel(); public native btLemkeSolver m_debugLevel(int setter); + public native int m_maxLoops(); public native btLemkeSolver m_maxLoops(int setter); + public native @Cast("bool") boolean m_useLoHighBounds(); public native btLemkeSolver m_useLoHighBounds(boolean setter); + + public btLemkeSolver() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("bool") boolean solveMLCP(@Const @ByRef btMatrixXf A, @Const @ByRef btVectorXf b, @ByRef btVectorXf x, @Const @ByRef btVectorXf lo, @Const @ByRef btVectorXf hi, @Const @ByRef btIntArray limitDependency, int numIterations, @Cast("bool") boolean useSparsity/*=true*/); + public native @Cast("bool") boolean solveMLCP(@Const @ByRef btMatrixXf A, @Const @ByRef btVectorXf b, @ByRef btVectorXf x, @Const @ByRef btVectorXf lo, @Const @ByRef btVectorXf hi, @Const @ByRef btIntArray limitDependency, int numIterations); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolver.java new file mode 100644 index 00000000000..3f1a4deb528 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolver.java @@ -0,0 +1,33 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMLCPSolver extends btSequentialImpulseConstraintSolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMLCPSolver(Pointer p) { super(p); } + + public btMLCPSolver(btMLCPSolverInterface solver) { super((Pointer)null); allocate(solver); } + private native void allocate(btMLCPSolverInterface solver); + + public native void setMLCPSolver(btMLCPSolverInterface solver); + + public native int getNumFallbacks(); + public native void setNumFallbacks(int num); + + public native @Cast("btConstraintSolverType") int getSolverType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolverInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolverInterface.java new file mode 100644 index 00000000000..7630baea581 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolverInterface.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMLCPSolverInterface extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btMLCPSolverInterface() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMLCPSolverInterface(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFixedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFixedConstraint.java new file mode 100644 index 00000000000..6e19d92b45f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFixedConstraint.java @@ -0,0 +1,55 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyFixedConstraint extends btMultiBodyConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyFixedConstraint(Pointer p) { super(p); } + + public btMultiBodyFixedConstraint(btMultiBody body, int link, btRigidBody bodyB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB) { super((Pointer)null); allocate(body, link, bodyB, pivotInA, pivotInB, frameInA, frameInB); } + private native void allocate(btMultiBody body, int link, btRigidBody bodyB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB); + public btMultiBodyFixedConstraint(btMultiBody bodyA, int linkA, btMultiBody bodyB, int linkB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB) { super((Pointer)null); allocate(bodyA, linkA, bodyB, linkB, pivotInA, pivotInB, frameInA, frameInB); } + private native void allocate(btMultiBody bodyA, int linkA, btMultiBody bodyB, int linkB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB); + + public native void finalizeMultiDof(); + + public native int getIslandIdA(); + public native int getIslandIdB(); + + public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + @ByRef btMultiBodyJacobianData data, + @Const @ByRef btContactSolverInfo infoGlobal); + + public native @Const @ByRef btVector3 getPivotInA(); + + public native void setPivotInA(@Const @ByRef btVector3 pivotInA); + + public native @Const @ByRef btVector3 getPivotInB(); + + public native void setPivotInB(@Const @ByRef btVector3 pivotInB); + + public native @Const @ByRef btMatrix3x3 getFrameInA(); + + public native void setFrameInA(@Const @ByRef btMatrix3x3 frameInA); + + public native @Const @ByRef btMatrix3x3 getFrameInB(); + + public native void setFrameInB(@Const @ByRef btMatrix3x3 frameInB); + + public native void debugDraw(btIDebugDraw drawer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyGearConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyGearConstraint.java new file mode 100644 index 00000000000..ec598f6707d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyGearConstraint.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyGearConstraint extends btMultiBodyConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyGearConstraint(Pointer p) { super(p); } + + //btMultiBodyGearConstraint(btMultiBody* body, int link, btRigidBody* bodyB, const btVector3& pivotInA, const btVector3& pivotInB, const btMatrix3x3& frameInA, const btMatrix3x3& frameInB); + public btMultiBodyGearConstraint(btMultiBody bodyA, int linkA, btMultiBody bodyB, int linkB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB) { super((Pointer)null); allocate(bodyA, linkA, bodyB, linkB, pivotInA, pivotInB, frameInA, frameInB); } + private native void allocate(btMultiBody bodyA, int linkA, btMultiBody bodyB, int linkB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB); + + public native void finalizeMultiDof(); + + public native int getIslandIdA(); + public native int getIslandIdB(); + + public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + @ByRef btMultiBodyJacobianData data, + @Const @ByRef btContactSolverInfo infoGlobal); + + public native @Const @ByRef btVector3 getPivotInA(); + + public native void setPivotInA(@Const @ByRef btVector3 pivotInA); + + public native @Const @ByRef btVector3 getPivotInB(); + + public native void setPivotInB(@Const @ByRef btVector3 pivotInB); + + public native @Const @ByRef btMatrix3x3 getFrameInA(); + + public native void setFrameInA(@Const @ByRef btMatrix3x3 frameInA); + + public native @Const @ByRef btMatrix3x3 getFrameInB(); + + public native void setFrameInB(@Const @ByRef btMatrix3x3 frameInB); + + public native void debugDraw(btIDebugDraw drawer); + + public native void setGearRatio(@Cast("btScalar") float gearRatio); + public native void setGearAuxLink(int gearAuxLink); + public native void setRelativePositionTarget(@Cast("btScalar") float relPosTarget); + public native void setErp(@Cast("btScalar") float erp); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointLimitConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointLimitConstraint.java new file mode 100644 index 00000000000..f84523a3abc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointLimitConstraint.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyJointLimitConstraint extends btMultiBodyConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyJointLimitConstraint(Pointer p) { super(p); } + + public btMultiBodyJointLimitConstraint(btMultiBody body, int link, @Cast("btScalar") float lower, @Cast("btScalar") float upper) { super((Pointer)null); allocate(body, link, lower, upper); } + private native void allocate(btMultiBody body, int link, @Cast("btScalar") float lower, @Cast("btScalar") float upper); + + public native void finalizeMultiDof(); + + public native int getIslandIdA(); + public native int getIslandIdB(); + + public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + @ByRef btMultiBodyJacobianData data, + @Const @ByRef btContactSolverInfo infoGlobal); + + public native void debugDraw(btIDebugDraw drawer); + public native @Cast("btScalar") float getLowerBound(); + public native @Cast("btScalar") float getUpperBound(); + public native void setLowerBound(@Cast("btScalar") float lower); + public native void setUpperBound(@Cast("btScalar") float upper); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointMotor.java new file mode 100644 index 00000000000..8234f34f082 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointMotor.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyJointMotor extends btMultiBodyConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyJointMotor(Pointer p) { super(p); } + + public btMultiBodyJointMotor(btMultiBody body, int link, @Cast("btScalar") float desiredVelocity, @Cast("btScalar") float maxMotorImpulse) { super((Pointer)null); allocate(body, link, desiredVelocity, maxMotorImpulse); } + private native void allocate(btMultiBody body, int link, @Cast("btScalar") float desiredVelocity, @Cast("btScalar") float maxMotorImpulse); + public btMultiBodyJointMotor(btMultiBody body, int link, int linkDoF, @Cast("btScalar") float desiredVelocity, @Cast("btScalar") float maxMotorImpulse) { super((Pointer)null); allocate(body, link, linkDoF, desiredVelocity, maxMotorImpulse); } + private native void allocate(btMultiBody body, int link, int linkDoF, @Cast("btScalar") float desiredVelocity, @Cast("btScalar") float maxMotorImpulse); + public native void finalizeMultiDof(); + + public native int getIslandIdA(); + public native int getIslandIdB(); + + public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + @ByRef btMultiBodyJacobianData data, + @Const @ByRef btContactSolverInfo infoGlobal); + + public native void setVelocityTarget(@Cast("btScalar") float velTarget, @Cast("btScalar") float kd/*=1.f*/); + public native void setVelocityTarget(@Cast("btScalar") float velTarget); + + public native void setPositionTarget(@Cast("btScalar") float posTarget, @Cast("btScalar") float kp/*=1.f*/); + public native void setPositionTarget(@Cast("btScalar") float posTarget); + + public native void setErp(@Cast("btScalar") float erp); + public native @Cast("btScalar") float getErp(); + public native void setRhsClamp(@Cast("btScalar") float rhsClamp); + public native void debugDraw(btIDebugDraw drawer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyMLCPConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyMLCPConstraintSolver.java new file mode 100644 index 00000000000..3a3feed578e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyMLCPConstraintSolver.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyMLCPConstraintSolver extends btMultiBodyConstraintSolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyMLCPConstraintSolver(Pointer p) { super(p); } + + + /** Constructor + * + * @param solver [in] MLCP solver. Assumed it's not null. + * @param maxLCPSize [in] Maximum size of LCP to solve using MLCP solver. If the MLCP size exceeds this number, sequaltial impulse method will be used. */ + public btMultiBodyMLCPConstraintSolver(btMLCPSolverInterface solver) { super((Pointer)null); allocate(solver); } + private native void allocate(btMLCPSolverInterface solver); + + /** Destructor */ + + /** Sets MLCP solver. Assumed it's not null. */ + public native void setMLCPSolver(btMLCPSolverInterface solver); + + /** Returns the number of fallbacks of using btSequentialImpulseConstraintSolver, which happens when the MLCP + * solver fails. */ + public native int getNumFallbacks(); + + /** Sets the number of fallbacks. This function may be used to reset the number to zero. */ + public native void setNumFallbacks(int num); + + /** Returns the constraint solver type. */ + public native @Cast("btConstraintSolverType") int getSolverType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyPoint2Point.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyPoint2Point.java new file mode 100644 index 00000000000..44ceb633a87 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyPoint2Point.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +//#define BTMBP2PCONSTRAINT_BLOCK_ANGULAR_MOTION_TEST + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyPoint2Point extends btMultiBodyConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyPoint2Point(Pointer p) { super(p); } + + + public btMultiBodyPoint2Point(btMultiBody body, int link, btRigidBody bodyB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB) { super((Pointer)null); allocate(body, link, bodyB, pivotInA, pivotInB); } + private native void allocate(btMultiBody body, int link, btRigidBody bodyB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB); + public btMultiBodyPoint2Point(btMultiBody bodyA, int linkA, btMultiBody bodyB, int linkB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB) { super((Pointer)null); allocate(bodyA, linkA, bodyB, linkB, pivotInA, pivotInB); } + private native void allocate(btMultiBody bodyA, int linkA, btMultiBody bodyB, int linkB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB); + + public native void finalizeMultiDof(); + + public native int getIslandIdA(); + public native int getIslandIdB(); + + public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + @ByRef btMultiBodyJacobianData data, + @Const @ByRef btContactSolverInfo infoGlobal); + + public native @Const @ByRef btVector3 getPivotInB(); + + public native void setPivotInB(@Const @ByRef btVector3 pivotInB); + + public native void debugDraw(btIDebugDraw drawer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySliderConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySliderConstraint.java new file mode 100644 index 00000000000..c6d4dc8c07b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySliderConstraint.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodySliderConstraint extends btMultiBodyConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodySliderConstraint(Pointer p) { super(p); } + + public btMultiBodySliderConstraint(btMultiBody body, int link, btRigidBody bodyB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB, @Const @ByRef btVector3 jointAxis) { super((Pointer)null); allocate(body, link, bodyB, pivotInA, pivotInB, frameInA, frameInB, jointAxis); } + private native void allocate(btMultiBody body, int link, btRigidBody bodyB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB, @Const @ByRef btVector3 jointAxis); + public btMultiBodySliderConstraint(btMultiBody bodyA, int linkA, btMultiBody bodyB, int linkB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB, @Const @ByRef btVector3 jointAxis) { super((Pointer)null); allocate(bodyA, linkA, bodyB, linkB, pivotInA, pivotInB, frameInA, frameInB, jointAxis); } + private native void allocate(btMultiBody bodyA, int linkA, btMultiBody bodyB, int linkB, @Const @ByRef btVector3 pivotInA, @Const @ByRef btVector3 pivotInB, @Const @ByRef btMatrix3x3 frameInA, @Const @ByRef btMatrix3x3 frameInB, @Const @ByRef btVector3 jointAxis); + + public native void finalizeMultiDof(); + + public native int getIslandIdA(); + public native int getIslandIdB(); + + public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + @ByRef btMultiBodyJacobianData data, + @Const @ByRef btContactSolverInfo infoGlobal); + + public native @Const @ByRef btVector3 getPivotInA(); + + public native void setPivotInA(@Const @ByRef btVector3 pivotInA); + + public native @Const @ByRef btVector3 getPivotInB(); + + public native void setPivotInB(@Const @ByRef btVector3 pivotInB); + + public native @Const @ByRef btMatrix3x3 getFrameInA(); + + public native void setFrameInA(@Const @ByRef btMatrix3x3 frameInA); + + public native @Const @ByRef btMatrix3x3 getFrameInB(); + + public native void setFrameInB(@Const @ByRef btMatrix3x3 frameInB); + + public native @Const @ByRef btVector3 getJointAxis(); + + public native void setJointAxis(@Const @ByRef btVector3 jointAxis); + + public native void debugDraw(btIDebugDraw drawer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySolverConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySolverConstraint.java new file mode 100644 index 00000000000..cf6609f8b77 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySolverConstraint.java @@ -0,0 +1,84 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodySolverConstraint extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodySolverConstraint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodySolverConstraint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMultiBodySolverConstraint position(long position) { + return (btMultiBodySolverConstraint)super.position(position); + } + @Override public btMultiBodySolverConstraint getPointer(long i) { + return new btMultiBodySolverConstraint((Pointer)this).offsetAddress(i); + } + + + public btMultiBodySolverConstraint() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native int m_deltaVelAindex(); public native btMultiBodySolverConstraint m_deltaVelAindex(int setter); //more generic version of m_relpos1CrossNormal/m_contactNormal1 + public native int m_jacAindex(); public native btMultiBodySolverConstraint m_jacAindex(int setter); + public native int m_deltaVelBindex(); public native btMultiBodySolverConstraint m_deltaVelBindex(int setter); + public native int m_jacBindex(); public native btMultiBodySolverConstraint m_jacBindex(int setter); + + public native @ByRef btVector3 m_relpos1CrossNormal(); public native btMultiBodySolverConstraint m_relpos1CrossNormal(btVector3 setter); + public native @ByRef btVector3 m_contactNormal1(); public native btMultiBodySolverConstraint m_contactNormal1(btVector3 setter); + public native @ByRef btVector3 m_relpos2CrossNormal(); public native btMultiBodySolverConstraint m_relpos2CrossNormal(btVector3 setter); + public native @ByRef btVector3 m_contactNormal2(); public native btMultiBodySolverConstraint m_contactNormal2(btVector3 setter); //usually m_contactNormal2 == -m_contactNormal1, but not always + + public native @ByRef btVector3 m_angularComponentA(); public native btMultiBodySolverConstraint m_angularComponentA(btVector3 setter); + public native @ByRef btVector3 m_angularComponentB(); public native btMultiBodySolverConstraint m_angularComponentB(btVector3 setter); + + public native @Cast("btScalar") float m_appliedPushImpulse(); public native btMultiBodySolverConstraint m_appliedPushImpulse(float setter); + public native @Cast("btScalar") float m_appliedImpulse(); public native btMultiBodySolverConstraint m_appliedImpulse(float setter); + + public native @Cast("btScalar") float m_friction(); public native btMultiBodySolverConstraint m_friction(float setter); + public native @Cast("btScalar") float m_jacDiagABInv(); public native btMultiBodySolverConstraint m_jacDiagABInv(float setter); + public native @Cast("btScalar") float m_rhs(); public native btMultiBodySolverConstraint m_rhs(float setter); + public native @Cast("btScalar") float m_cfm(); public native btMultiBodySolverConstraint m_cfm(float setter); + + public native @Cast("btScalar") float m_lowerLimit(); public native btMultiBodySolverConstraint m_lowerLimit(float setter); + public native @Cast("btScalar") float m_upperLimit(); public native btMultiBodySolverConstraint m_upperLimit(float setter); + public native @Cast("btScalar") float m_rhsPenetration(); public native btMultiBodySolverConstraint m_rhsPenetration(float setter); + public native Pointer m_originalContactPoint(); public native btMultiBodySolverConstraint m_originalContactPoint(Pointer setter); + public native @Cast("btScalar") float m_unusedPadding4(); public native btMultiBodySolverConstraint m_unusedPadding4(float setter); + + public native int m_overrideNumSolverIterations(); public native btMultiBodySolverConstraint m_overrideNumSolverIterations(int setter); + public native int m_frictionIndex(); public native btMultiBodySolverConstraint m_frictionIndex(int setter); + + public native int m_solverBodyIdA(); public native btMultiBodySolverConstraint m_solverBodyIdA(int setter); + public native btMultiBody m_multiBodyA(); public native btMultiBodySolverConstraint m_multiBodyA(btMultiBody setter); + public native int m_linkA(); public native btMultiBodySolverConstraint m_linkA(int setter); + + public native int m_solverBodyIdB(); public native btMultiBodySolverConstraint m_solverBodyIdB(int setter); + public native btMultiBody m_multiBodyB(); public native btMultiBodySolverConstraint m_multiBodyB(btMultiBody setter); + public native int m_linkB(); public native btMultiBodySolverConstraint m_linkB(int setter); + + //for writing back applied impulses + public native btMultiBodyConstraint m_orgConstraint(); public native btMultiBodySolverConstraint m_orgConstraint(btMultiBodyConstraint setter); + public native int m_orgDofIndex(); public native btMultiBodySolverConstraint m_orgDofIndex(int setter); + + /** enum btMultiBodySolverConstraint::btSolverConstraintType */ + public static final int + BT_SOLVER_CONTACT_1D = 0, + BT_SOLVER_FRICTION_1D = 1; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySolverConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySolverConstraintArray.java new file mode 100644 index 00000000000..78336f65161 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySolverConstraintArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodySolverConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodySolverConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodySolverConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMultiBodySolverConstraintArray position(long position) { + return (btMultiBodySolverConstraintArray)super.position(position); + } + @Override public btMultiBodySolverConstraintArray getPointer(long i) { + return new btMultiBodySolverConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btMultiBodySolverConstraintArray put(@Const @ByRef btMultiBodySolverConstraintArray other); + public btMultiBodySolverConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btMultiBodySolverConstraintArray(@Const @ByRef btMultiBodySolverConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btMultiBodySolverConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btMultiBodySolverConstraint at(int n); + + public native @ByRef @Name("operator []") btMultiBodySolverConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btMultiBodySolverConstraint()") btMultiBodySolverConstraint fillData); + public native void resize(int newsize); + public native @ByRef btMultiBodySolverConstraint expandNonInitializing(); + + public native @ByRef btMultiBodySolverConstraint expand(@Const @ByRef(nullValue = "btMultiBodySolverConstraint()") btMultiBodySolverConstraint fillValue); + public native @ByRef btMultiBodySolverConstraint expand(); + + public native void push_back(@Const @ByRef btMultiBodySolverConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btMultiBodySolverConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySphericalJointMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySphericalJointMotor.java new file mode 100644 index 00000000000..82571bcd9a0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySphericalJointMotor.java @@ -0,0 +1,60 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodySphericalJointMotor extends btMultiBodyConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodySphericalJointMotor(Pointer p) { super(p); } + + public btMultiBodySphericalJointMotor(btMultiBody body, int link, @Cast("btScalar") float maxMotorImpulse) { super((Pointer)null); allocate(body, link, maxMotorImpulse); } + private native void allocate(btMultiBody body, int link, @Cast("btScalar") float maxMotorImpulse); + public native void finalizeMultiDof(); + + public native int getIslandIdA(); + public native int getIslandIdB(); + + public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + @ByRef btMultiBodyJacobianData data, + @Const @ByRef btContactSolverInfo infoGlobal); + + public native void setVelocityTarget(@Const @ByRef btVector3 velTarget, @Cast("btScalar") float kd/*=1.0*/); + public native void setVelocityTarget(@Const @ByRef btVector3 velTarget); + + public native void setVelocityTargetMultiDof(@Const @ByRef btVector3 velTarget, @Const @ByRef(nullValue = "btVector3(1.0, 1.0, 1.0)") btVector3 kd); + public native void setVelocityTargetMultiDof(@Const @ByRef btVector3 velTarget); + + public native void setPositionTarget(@Const @ByRef btQuaternion posTarget, @Cast("btScalar") float kp/*=1.f*/); + public native void setPositionTarget(@Const @ByRef btQuaternion posTarget); + + public native void setPositionTargetMultiDof(@Const @ByRef btQuaternion posTarget, @Const @ByRef(nullValue = "btVector3(1.f, 1.f, 1.f)") btVector3 kp); + public native void setPositionTargetMultiDof(@Const @ByRef btQuaternion posTarget); + + public native void setErp(@Cast("btScalar") float erp); + public native @Cast("btScalar") float getErp(); + public native void setRhsClamp(@Cast("btScalar") float rhsClamp); + + public native @Cast("btScalar") float getMaxAppliedImpulseMultiDof(int i); + + public native void setMaxAppliedImpulseMultiDof(@Const @ByRef btVector3 maxImp); + + public native @Cast("btScalar") float getDamping(int i); + + public native void setDamping(@Const @ByRef btVector3 damping); + + public native void debugDraw(btIDebugDraw drawer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btNNCGConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btNNCGConstraintSolver.java new file mode 100644 index 00000000000..cf25d86ecd8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btNNCGConstraintSolver.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btNNCGConstraintSolver extends btSequentialImpulseConstraintSolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btNNCGConstraintSolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btNNCGConstraintSolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btNNCGConstraintSolver position(long position) { + return (btNNCGConstraintSolver)super.position(position); + } + @Override public btNNCGConstraintSolver getPointer(long i) { + return new btNNCGConstraintSolver((Pointer)this).offsetAddress(i); + } + + + public btNNCGConstraintSolver() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("btConstraintSolverType") int getSolverType(); + + public native @Cast("bool") boolean m_onlyForNoneContact(); public native btNNCGConstraintSolver m_onlyForNoneContact(boolean setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolveProjectedGaussSeidel.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolveProjectedGaussSeidel.java new file mode 100644 index 00000000000..df11ccd6f6a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolveProjectedGaussSeidel.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**This solver is mainly for debug/learning purposes: it is functionally equivalent to the btSequentialImpulseConstraintSolver solver, but much slower (it builds the full LCP matrix) */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolveProjectedGaussSeidel extends btMLCPSolverInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolveProjectedGaussSeidel(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSolveProjectedGaussSeidel(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSolveProjectedGaussSeidel position(long position) { + return (btSolveProjectedGaussSeidel)super.position(position); + } + @Override public btSolveProjectedGaussSeidel getPointer(long i) { + return new btSolveProjectedGaussSeidel((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_leastSquaresResidualThreshold(); public native btSolveProjectedGaussSeidel m_leastSquaresResidualThreshold(float setter); + public native @Cast("btScalar") float m_leastSquaresResidual(); public native btSolveProjectedGaussSeidel m_leastSquaresResidual(float setter); + + public btSolveProjectedGaussSeidel() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean solveMLCP(@Const @ByRef btMatrixXf A, @Const @ByRef btVectorXf b, @ByRef btVectorXf x, @Const @ByRef btVectorXf lo, @Const @ByRef btVectorXf hi, @Const @ByRef btIntArray limitDependency, int numIterations, @Cast("bool") boolean useSparsity/*=true*/); + public native @Cast("bool") boolean solveMLCP(@Const @ByRef btMatrixXf A, @Const @ByRef btVectorXf b, @ByRef btVectorXf x, @Const @ByRef btVectorXf lo, @Const @ByRef btVectorXf hi, @Const @ByRef btIntArray limitDependency, int numIterations); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDoubleArray.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDoubleArray.java new file mode 100644 index 00000000000..6975f3eb7c9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDoubleArray.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btDoubleArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDoubleArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDoubleArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDoubleArray position(long position) { + return (btDoubleArray)super.position(position); + } + @Override public btDoubleArray getPointer(long i) { + return new btDoubleArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDoubleArray put(@Const @ByRef btDoubleArray other); + public btDoubleArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDoubleArray(@Const @ByRef btDoubleArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDoubleArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef DoublePointer at(int n); + + public native @ByRef @Name("operator []") DoublePointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, double fillData/*=double()*/); + public native void resize(int newsize); + public native @ByRef DoublePointer expandNonInitializing(); + + public native @ByRef DoublePointer expand(double fillValue/*=double()*/); + public native @ByRef DoublePointer expand(); + + public native void push_back(double _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(double key); + + public native int findLinearSearch(double key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(double key); + + public native void removeAtIndex(int index); + public native void remove(double key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDoubleArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntArrayArray.java new file mode 100644 index 00000000000..30e2b5982f0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntArrayArray.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btIntArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIntArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btIntArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btIntArrayArray position(long position) { + return (btIntArrayArray)super.position(position); + } + @Override public btIntArrayArray getPointer(long i) { + return new btIntArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btIntArrayArray put(@Const @ByRef btIntArrayArray other); + public btIntArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btIntArrayArray(@Const @ByRef btIntArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btIntArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btIntArray at(int n); + + public native @ByRef @Name("operator []") btIntArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btIntArray fillData); + public native void resize(int newsize); + public native @ByRef btIntArray expandNonInitializing(); + + public native @ByRef btIntArray expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btIntArray fillValue); + public native @ByRef btIntArray expand(); + + public native void push_back(@Const @ByRef btIntArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btIntArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntSortPredicate.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntSortPredicate.java new file mode 100644 index 00000000000..e0be6d013dc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btIntSortPredicate.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +//#define BT_DEBUG_OSTREAM +// #ifdef BT_DEBUG_OSTREAM +// #endif //BT_DEBUG_OSTREAM + +@Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btIntSortPredicate extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btIntSortPredicate() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btIntSortPredicate(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btIntSortPredicate(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btIntSortPredicate position(long position) { + return (btIntSortPredicate)super.position(position); + } + @Override public btIntSortPredicate getPointer(long i) { + return new btIntSortPredicate((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") @Name("operator ()") boolean apply(int a, int b); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrixXd.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrixXd.java new file mode 100644 index 00000000000..8d93fc318a7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrixXd.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Name("btMatrixX") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btMatrixXd extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMatrixXd(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMatrixXd(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMatrixXd position(long position) { + return (btMatrixXd)super.position(position); + } + @Override public btMatrixXd getPointer(long i) { + return new btMatrixXd((Pointer)this).offsetAddress(i); + } + + public native int m_rows(); public native btMatrixXd m_rows(int setter); + public native int m_cols(); public native btMatrixXd m_cols(int setter); + public native int m_operations(); public native btMatrixXd m_operations(int setter); + public native int m_resizeOperations(); public native btMatrixXd m_resizeOperations(int setter); + public native int m_setElemOperations(); public native btMatrixXd m_setElemOperations(int setter); + + public native @ByRef btDoubleArray m_storage(); public native btMatrixXd m_storage(btDoubleArray setter); + public native @ByRef btIntArrayArray m_rowNonZeroElements1(); public native btMatrixXd m_rowNonZeroElements1(btIntArrayArray setter); + + public native DoublePointer getBufferPointerWritable(); + + public native @Const DoublePointer getBufferPointer(); + public btMatrixXd() { super((Pointer)null); allocate(); } + private native void allocate(); + public btMatrixXd(int rows, int cols) { super((Pointer)null); allocate(rows, cols); } + private native void allocate(int rows, int cols); + public native void resize(int rows, int cols); + public native int cols(); + public native int rows(); + /**we don't want this read/write operator(), because we cannot keep track of non-zero elements, use setElem instead */ + /*T& operator() (int row,int col) + { + return m_storage[col*m_rows+row]; + } + */ + + public native void addElem(int row, int col, double val); + + public native void setElem(int row, int col, double val); + + public native void mulElem(int row, int col, double val); + + public native void copyLowerToUpperTriangle(); + + public native @Name("operator ()") double apply(int row, int col); + + public native void setZero(); + + public native void setIdentity(); + + public native void printMatrix(@Cast("const char*") BytePointer msg); + public native void printMatrix(String msg); + + public native void rowComputeNonZeroElements(); + public native @ByVal btMatrixXd transpose(); + + public native @ByVal @Name("operator *") btMatrixXd multiply(@Const @ByRef btMatrixXd other); + + // this assumes the 4th and 8th rows of B and C are zero. + public native void multiplyAdd2_p8r(@Cast("const btScalar*") FloatPointer B, @Cast("const btScalar*") FloatPointer C, int numRows, int numRowsOther, int row, int col); + public native void multiplyAdd2_p8r(@Cast("const btScalar*") FloatBuffer B, @Cast("const btScalar*") FloatBuffer C, int numRows, int numRowsOther, int row, int col); + public native void multiplyAdd2_p8r(@Cast("const btScalar*") float[] B, @Cast("const btScalar*") float[] C, int numRows, int numRowsOther, int row, int col); + + public native void multiply2_p8r(@Cast("const btScalar*") FloatPointer B, @Cast("const btScalar*") FloatPointer C, int numRows, int numRowsOther, int row, int col); + public native void multiply2_p8r(@Cast("const btScalar*") FloatBuffer B, @Cast("const btScalar*") FloatBuffer C, int numRows, int numRowsOther, int row, int col); + public native void multiply2_p8r(@Cast("const btScalar*") float[] B, @Cast("const btScalar*") float[] C, int numRows, int numRowsOther, int row, int col); + + public native void setSubMatrix(int rowstart, int colstart, int rowend, int colend, double value); + + public native void setSubMatrix(int rowstart, int colstart, int rowend, int colend, @Const @ByRef btMatrixXd block); + public native void setSubMatrix(int rowstart, int colstart, int rowend, int colend, @Const @ByRef btVectorXd block); + + public native @ByVal btMatrixXd negative(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrixXf.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrixXf.java new file mode 100644 index 00000000000..3b452ff68fd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btMatrixXf.java @@ -0,0 +1,99 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +/* + template + void setElem(btMatrixX& mat, int row, int col, T val) + { + mat.setElem(row,col,val); + } + */ + +@Name("btMatrixX") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btMatrixXf extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMatrixXf(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMatrixXf(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMatrixXf position(long position) { + return (btMatrixXf)super.position(position); + } + @Override public btMatrixXf getPointer(long i) { + return new btMatrixXf((Pointer)this).offsetAddress(i); + } + + public native int m_rows(); public native btMatrixXf m_rows(int setter); + public native int m_cols(); public native btMatrixXf m_cols(int setter); + public native int m_operations(); public native btMatrixXf m_operations(int setter); + public native int m_resizeOperations(); public native btMatrixXf m_resizeOperations(int setter); + public native int m_setElemOperations(); public native btMatrixXf m_setElemOperations(int setter); + + public native @ByRef btScalarArray m_storage(); public native btMatrixXf m_storage(btScalarArray setter); + public native @ByRef btIntArrayArray m_rowNonZeroElements1(); public native btMatrixXf m_rowNonZeroElements1(btIntArrayArray setter); + + public native FloatPointer getBufferPointerWritable(); + + public native @Const FloatPointer getBufferPointer(); + public btMatrixXf() { super((Pointer)null); allocate(); } + private native void allocate(); + public btMatrixXf(int rows, int cols) { super((Pointer)null); allocate(rows, cols); } + private native void allocate(int rows, int cols); + public native void resize(int rows, int cols); + public native int cols(); + public native int rows(); + /**we don't want this read/write operator(), because we cannot keep track of non-zero elements, use setElem instead */ + /*T& operator() (int row,int col) + { + return m_storage[col*m_rows+row]; + } + */ + + public native void addElem(int row, int col, float val); + + public native void setElem(int row, int col, float val); + + public native void mulElem(int row, int col, float val); + + public native void copyLowerToUpperTriangle(); + + public native @Name("operator ()") float apply(int row, int col); + + public native void setZero(); + + public native void setIdentity(); + + public native void printMatrix(@Cast("const char*") BytePointer msg); + public native void printMatrix(String msg); + + public native void rowComputeNonZeroElements(); + public native @ByVal btMatrixXf transpose(); + + public native @ByVal @Name("operator *") btMatrixXf multiply(@Const @ByRef btMatrixXf other); + + // this assumes the 4th and 8th rows of B and C are zero. + public native void multiplyAdd2_p8r(@Cast("const btScalar*") FloatPointer B, @Cast("const btScalar*") FloatPointer C, int numRows, int numRowsOther, int row, int col); + public native void multiplyAdd2_p8r(@Cast("const btScalar*") FloatBuffer B, @Cast("const btScalar*") FloatBuffer C, int numRows, int numRowsOther, int row, int col); + public native void multiplyAdd2_p8r(@Cast("const btScalar*") float[] B, @Cast("const btScalar*") float[] C, int numRows, int numRowsOther, int row, int col); + + public native void multiply2_p8r(@Cast("const btScalar*") FloatPointer B, @Cast("const btScalar*") FloatPointer C, int numRows, int numRowsOther, int row, int col); + public native void multiply2_p8r(@Cast("const btScalar*") FloatBuffer B, @Cast("const btScalar*") FloatBuffer C, int numRows, int numRowsOther, int row, int col); + public native void multiply2_p8r(@Cast("const btScalar*") float[] B, @Cast("const btScalar*") float[] C, int numRows, int numRowsOther, int row, int col); + + public native void setSubMatrix(int rowstart, int colstart, int rowend, int colend, float value); + + public native void setSubMatrix(int rowstart, int colstart, int rowend, int colend, @Const @ByRef btMatrixXf block); + public native void setSubMatrix(int rowstart, int colstart, int rowend, int colend, @Const @ByRef btVectorXf block); + + public native @ByVal btMatrixXf negative(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btScalarArray.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btScalarArray.java index 5abb1c0e6db..b447bee7f8f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btScalarArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btScalarArray.java @@ -10,7 +10,7 @@ import static org.bytedeco.bullet.global.LinearMath.*; -@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) public class btScalarArray extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ @@ -36,9 +36,9 @@ public class btScalarArray extends Pointer { /** return the number of elements in the array */ public native int size(); - public native @Cast("btScalar*") @ByRef FloatPointer at(int n); + public native @ByRef FloatPointer at(int n); - public native @Cast("btScalar*") @ByRef @Name("operator []") FloatPointer get(int n); + public native @ByRef @Name("operator []") FloatPointer get(int n); /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ public native void clear(); @@ -49,14 +49,14 @@ public class btScalarArray extends Pointer { * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ public native void resizeNoInitialize(int newsize); - public native void resize(int newsize, @Cast("const btScalar") float fillData/*=btScalar()*/); + public native void resize(int newsize, float fillData/*=float()*/); public native void resize(int newsize); - public native @Cast("btScalar*") @ByRef FloatPointer expandNonInitializing(); + public native @ByRef FloatPointer expandNonInitializing(); - public native @Cast("btScalar*") @ByRef FloatPointer expand(@Cast("const btScalar") float fillValue/*=btScalar()*/); - public native @Cast("btScalar*") @ByRef FloatPointer expand(); + public native @ByRef FloatPointer expand(float fillValue/*=float()*/); + public native @ByRef FloatPointer expand(); - public native void push_back(@Cast("const btScalar") float _Val); + public native void push_back(float _Val); /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ public native @Name("capacity") int _capacity(); @@ -68,16 +68,16 @@ public class btScalarArray extends Pointer { public native void swap(int index0, int index1); /**non-recursive binary search, assumes sorted array */ - public native int findBinarySearch(@Cast("const btScalar") float key); + public native int findBinarySearch(float key); - public native int findLinearSearch(@Cast("const btScalar") float key); + public native int findLinearSearch(float key); // If the key is not in the array, return -1 instead of 0, // since 0 also means the first element in the array. - public native int findLinearSearch2(@Cast("const btScalar") float key); + public native int findLinearSearch2(float key); public native void removeAtIndex(int index); - public native void remove(@Cast("const btScalar") float key); + public native void remove(float key); //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVectorXd.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVectorXd.java new file mode 100644 index 00000000000..d7744438c0b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVectorXd.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Name("btVectorX") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btVectorXd extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVectorXd(Pointer p) { super(p); } + + public native @ByRef btDoubleArray m_storage(); public native btVectorXd m_storage(btDoubleArray setter); + + public btVectorXd() { super((Pointer)null); allocate(); } + private native void allocate(); + public btVectorXd(int numRows) { super((Pointer)null); allocate(numRows); } + private native void allocate(int numRows); + + public native void resize(int rows); + public native int cols(); + public native int rows(); + public native int size(); + + public native double nrm2(); + public native void setZero(); + + public native @ByRef @Name("operator []") DoublePointer get(int index); + + public native DoublePointer getBufferPointerWritable(); + + public native @Const DoublePointer getBufferPointer(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVectorXf.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVectorXf.java new file mode 100644 index 00000000000..eb1a44c28ca --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btVectorXf.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + + +@Name("btVectorX") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btVectorXf extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btVectorXf(Pointer p) { super(p); } + + public native @ByRef btScalarArray m_storage(); public native btVectorXf m_storage(btScalarArray setter); + + public btVectorXf() { super((Pointer)null); allocate(); } + private native void allocate(); + public btVectorXf(int numRows) { super((Pointer)null); allocate(numRows); } + private native void allocate(int numRows); + + public native void resize(int rows); + public native int cols(); + public native int rows(); + public native int size(); + + public native float nrm2(); + public native void setZero(); + + public native @ByRef @Name("operator []") FloatPointer get(int index); + + public native FloatPointer getBufferPointerWritable(); + + public native @Const FloatPointer getBufferPointer(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index 414b9add18e..d34f4e23e94 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -60,6 +60,9 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // Targeting ../BulletDynamics/btRigidBodyArray.java +// Targeting ../BulletDynamics/btMultiBodySolverConstraintArray.java + + // #endif //BT_OBJECT_ARRAY__ @@ -1298,6 +1301,34 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H +// Parsed from BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_NNCG_CONSTRAINT_SOLVER_H +// #define BT_NNCG_CONSTRAINT_SOLVER_H + +// #include "btSequentialImpulseConstraintSolver.h" +// Targeting ../BulletDynamics/btNNCGConstraintSolver.java + + + +// #endif //BT_NNCG_CONSTRAINT_SOLVER_H + + // Parsed from BulletDynamics/Vehicle/btVehicleRaycaster.h /* @@ -1676,4 +1707,396 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_MULTIBODY_CONSTRAINT_SOLVER_H +// Parsed from BulletDynamics/Featherstone/btMultiBodySolverConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_SOLVER_CONSTRAINT_H +// #define BT_MULTIBODY_SOLVER_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" +// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +// Targeting ../BulletDynamics/btMultiBodySolverConstraint.java + + + +// #endif //BT_MULTIBODY_SOLVER_CONSTRAINT_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyFixedConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef BT_MULTIBODY_FIXED_CONSTRAINT_H +// #define BT_MULTIBODY_FIXED_CONSTRAINT_H + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodyFixedConstraint.java + + + +// #endif //BT_MULTIBODY_FIXED_CONSTRAINT_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyGearConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef BT_MULTIBODY_GEAR_CONSTRAINT_H +// #define BT_MULTIBODY_GEAR_CONSTRAINT_H + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodyGearConstraint.java + + + +// #endif //BT_MULTIBODY_GEAR_CONSTRAINT_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_JOINT_LIMIT_CONSTRAINT_H +// #define BT_MULTIBODY_JOINT_LIMIT_CONSTRAINT_H + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodyJointLimitConstraint.java + + + +// #endif //BT_MULTIBODY_JOINT_LIMIT_CONSTRAINT_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyJointMotor.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef BT_MULTIBODY_JOINT_MOTOR_H +// #define BT_MULTIBODY_JOINT_MOTOR_H + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodyJointMotor.java + + + +// #endif //BT_MULTIBODY_JOINT_MOTOR_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyPoint2Point.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef BT_MULTIBODY_POINT2POINT_H +// #define BT_MULTIBODY_POINT2POINT_H + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodyPoint2Point.java + + + +// #endif //BT_MULTIBODY_POINT2POINT_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodySliderConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef BT_MULTIBODY_SLIDER_CONSTRAINT_H +// #define BT_MULTIBODY_SLIDER_CONSTRAINT_H + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodySliderConstraint.java + + + +// #endif //BT_MULTIBODY_SLIDER_CONSTRAINT_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2018 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H +// #define BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodySphericalJointMotor.java + + + +// #endif //BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2018 Google Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H +// #define BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H + +// #include "LinearMath/btMatrixX.h" +// #include "LinearMath/btThreads.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" +// Targeting ../BulletDynamics/btMLCPSolverInterface.java + + +// Targeting ../BulletDynamics/btMultiBodyMLCPConstraintSolver.java + + + +// #endif // BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H + + +// Parsed from BulletDynamics/MLCPSolvers/btDantzigSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**original version written by Erwin Coumans, October 2013 */ + +// #ifndef BT_DANTZIG_SOLVER_H +// #define BT_DANTZIG_SOLVER_H + +// #include "btMLCPSolverInterface.h" +// #include "btDantzigLCP.h" +// Targeting ../BulletDynamics/btDantzigSolver.java + + + +// #endif //BT_DANTZIG_SOLVER_H + + +// Parsed from BulletDynamics/MLCPSolvers/btLemkeSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**original version written by Erwin Coumans, October 2013 */ + +// #ifndef BT_LEMKE_SOLVER_H +// #define BT_LEMKE_SOLVER_H + +// #include "btMLCPSolverInterface.h" +// #include "btLemkeAlgorithm.h" +// Targeting ../BulletDynamics/btLemkeSolver.java + + + +// #endif //BT_LEMKE_SOLVER_H + + +// Parsed from BulletDynamics/MLCPSolvers/btMLCPSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**original version written by Erwin Coumans, October 2013 */ + +// #ifndef BT_MLCP_SOLVER_H +// #define BT_MLCP_SOLVER_H + +// #include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" +// #include "LinearMath/btMatrixX.h" +// #include "BulletDynamics/MLCPSolvers/btMLCPSolverInterface.h" +// Targeting ../BulletDynamics/btMLCPSolver.java + + + +// #endif //BT_MLCP_SOLVER_H + + +// Parsed from BulletDynamics/MLCPSolvers/btSolveProjectedGaussSeidel.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**original version written by Erwin Coumans, October 2013 */ + +// #ifndef BT_SOLVE_PROJECTED_GAUSS_SEIDEL_H +// #define BT_SOLVE_PROJECTED_GAUSS_SEIDEL_H + +// #include "btMLCPSolverInterface.h" +// Targeting ../BulletDynamics/btSolveProjectedGaussSeidel.java + + + +// #endif //BT_SOLVE_PROJECTED_GAUSS_SEIDEL_H + + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index 015ec5fc405..f341b571bb9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -731,6 +731,9 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // Targeting ../LinearMath/btScalarArray.java +// Targeting ../LinearMath/btDoubleArray.java + + // Targeting ../LinearMath/btMatrix3x3Array.java @@ -752,6 +755,9 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // Targeting ../LinearMath/btConvexHullComputerEdgeArray.java +// Targeting ../LinearMath/btIntArrayArray.java + + // #endif //BT_OBJECT_ARRAY__ @@ -1504,4 +1510,61 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // #endif //BT_TRANSFORM_UTIL_H +// Parsed from LinearMath/btMatrixX.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**original version written by Erwin Coumans, October 2013 */ + +// #ifndef BT_MATRIX_X_H +// #define BT_MATRIX_X_H + +// #include "LinearMath/btQuickprof.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include +// Targeting ../LinearMath/btIntSortPredicate.java + + +// Targeting ../LinearMath/btVectorXf.java + + +// Targeting ../LinearMath/btVectorXd.java + + +// Targeting ../LinearMath/btMatrixXf.java + + +// Targeting ../LinearMath/btMatrixXd.java + + + +// #ifdef BT_DEBUG_OSTREAM + +// #endif //BT_DEBUG_OSTREAM + +public static native void setElem(@ByRef btMatrixXd mat, int row, int col, double val); + +public static native void setElem(@ByRef btMatrixXf mat, int row, int col, float val); + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btVectorXu btVectorXf +// #define btMatrixXu btMatrixXf +// #endif //BT_USE_DOUBLE_PRECISION + +// #endif //BT_MATRIX_H_H + + } From 9cd12177e86707b35b5deaf125ab46d8d18946ce Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 9 Mar 2022 22:20:38 +0800 Subject: [PATCH 47/81] Use `.translate(false)` instead of `.cppText(#define` Choose the right definition automatically, instead of hardcoding it. --- .../bullet/presets/BulletCollision.java | 11 ++++--- .../bullet/presets/BulletDynamics.java | 30 ++++++++++--------- .../bullet/presets/BulletSoftBody.java | 2 +- .../bytedeco/bullet/presets/LinearMath.java | 1 + 4 files changed, 25 insertions(+), 19 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index eca8d709eef..ff6a8396cfb 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -136,10 +136,13 @@ public void map(InfoMap infoMap) { .put(new Info("btAxisSweep3").base("btBroadphaseInterface")) .put(new Info("BT_DECLARE_STACK_ONLY_OBJECT").cppText("#define BT_DECLARE_STACK_ONLY_OBJECT")) - .put(new Info("btCollisionObjectData").cppText("#define btCollisionObjectData btCollisionObjectFloatData")) - .put(new Info("btOptimizedBvhNodeData").cppText("#define btOptimizedBvhNodeData btOptimizedBvhNodeFloatData")) - .put(new Info("btPersistentManifoldData").cppText("#define btPersistentManifoldData btPersistentManifoldFloatData")) - .put(new Info("btQuantizedBvhData").cppText("#define btQuantizedBvhData btQuantizedBvhFloatData")) + + .put(new Info( + "btCollisionObjectData", + "btOptimizedBvhNodeData", + "btPersistentManifoldData", + "btQuantizedBvhData" + ).cppTypes().translate(false)) .put(new Info("DBVT_INLINE").cppTypes().annotations()) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index 90d0e2e7fa9..7695cade467 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -102,24 +102,26 @@ public class BulletDynamics implements InfoMapper { public void map(InfoMap infoMap) { infoMap - .put(new Info("btConeTwistConstraintData2").cppText("#define btConeTwistConstraintData2 btConeTwistConstraintData")) - .put(new Info("btGearConstraintData").cppText("#define btGearConstraintData btGearConstraintFloatData")) - .put(new Info("btGeneric6DofConstraintData2").cppText("#define btGeneric6DofConstraintData2 btGeneric6DofConstraintDoubleData2")) - .put(new Info("btGeneric6DofSpring2ConstraintData2").cppText("#define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData")) - .put(new Info("btGeneric6DofSpringConstraintData2").cppText("#define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData")) - .put(new Info("btHingeConstraintData").cppText("#define btHingeConstraintData btHingeConstraintFloatData")) - .put(new Info("btMultiBodyData").cppText("#define btMultiBodyData btMultiBodyFloatData")) - .put(new Info("btMultiBodyLinkColliderData").cppText("#define btMultiBodyLinkColliderData btMultiBodyLinkColliderFloatData")) - .put(new Info("btMultiBodyLinkData").cppText("#define btMultiBodyLinkData btMultiBodyLinkFloatData")) - .put(new Info("btPoint2PointConstraintData2").cppText("#define btPoint2PointConstraintData2 btPoint2PointConstraintDoubleData2")) - .put(new Info("btRigidBodyData").cppText("#define btRigidBodyData btRigidBodyFloatData")) .put(new Info("btSimdScalar").cppText("#define btSimdScalar btScalar")) - .put(new Info("btSliderConstraintData2").cppText("#define btSliderConstraintData2 btSliderConstraintDoubleData2")) - .put(new Info("btTypedConstraintData2").cppText("#define btTypedConstraintData2 btTypedConstraintFloatData")) + + .put(new Info( + "btConeTwistConstraintData2", + "btGearConstraintData", + "btGeneric6DofConstraintData2", + "btGeneric6DofSpring2ConstraintData2", + "btGeneric6DofSpringConstraintData2", + "btHingeConstraintData", + "btMultiBodyData", + "btMultiBodyLinkColliderData", + "btMultiBodyLinkData", + "btPoint2PointConstraintData2", + "btRigidBodyData", + "btSliderConstraintData2", + "btTypedConstraintData2" + ).cppTypes().translate(false)) .put(new Info( "IN_PARALLELL_SOLVER", - "USE_SIMD", "defined(BT_CLAMP_VELOCITY_TO) && BT_CLAMP_VELOCITY_TO > 0" ).define(false)) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 982b018ec7b..33a994df353 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -68,7 +68,7 @@ public class BulletSoftBody implements InfoMapper { public void map(InfoMap infoMap) { infoMap - .put(new Info("btSoftBodyData").cppText("#define btSoftBodyData btSoftBodyFloatData")) + .put(new Info("btSoftBodyData").cppTypes().translate(false)) .put(new Info("btSoftBodySolver::SolverTypes").enumerate()) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 26707a5d440..e2ac79fc746 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -95,6 +95,7 @@ public void map(InfoMap infoMap) { "BT_USE_SSE", "ENABLE_INMEMORY_SERIALIZER", "USE_LIBSPE2", + "USE_SIMD", "_WIN32", "defined BT_USE_SSE", "defined(BT_USE_DOUBLE_PRECISION)", From d8c0ca3d719850ff54e83584f88753bf9d5ab104 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 9 Mar 2022 22:46:45 +0800 Subject: [PATCH 48/81] Sort includes of bullet's mappers Improve maintenance. --- .../bullet/presets/BulletCollision.java | 94 +++++++++---------- .../bullet/presets/BulletDynamics.java | 52 +++++----- .../bullet/presets/BulletSoftBody.java | 16 ++-- 3 files changed, 81 insertions(+), 81 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index ff6a8396cfb..f46cf4a5871 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -40,85 +40,85 @@ @Platform( include = { "LinearMath/btAlignedObjectArray.h", - "BulletCollision/BroadphaseCollision/btDbvt.h", - "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h", + "BulletCollision/BroadphaseCollision/btAxisSweep3.h", + "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h", "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h", + "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h", + "BulletCollision/BroadphaseCollision/btDbvt.h", + "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h", "BulletCollision/BroadphaseCollision/btDispatcher.h", - "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h", "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h", + "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h", "BulletCollision/BroadphaseCollision/btQuantizedBvh.h", - "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h", "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h", - "BulletCollision/BroadphaseCollision/btAxisSweep3.h", - "BulletCollision/BroadphaseCollision/btDbvtBroadphase.h", - "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h", - "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h", + "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h", + "BulletCollision/NarrowPhaseCollision/btConvexCast.h", "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h", - "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h", "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h", - "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h", - "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h", - "BulletCollision/NarrowPhaseCollision/btConvexCast.h", - "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h", "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h", "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h", "BulletCollision/NarrowPhaseCollision/btGjkEpa3.h", + "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h", "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h", + "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h", "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h", "BulletCollision/NarrowPhaseCollision/btMprPenetration.h", + "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h", "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h", - "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h", "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h", + "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h", + "BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h", + "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h", + "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btCollisionConfiguration.h", - "BulletCollision/CollisionDispatch/btCollisionObject.h", "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h", "BulletCollision/CollisionDispatch/btCollisionDispatcher.h", - "BulletCollision/CollisionDispatch/btCollisionWorld.h", - "BulletCollision/CollisionDispatch/btManifoldResult.h", - "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h", - "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h", - "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h", - "BulletCollision/CollisionDispatch/btSimulationIslandManager.h", - "BulletCollision/CollisionDispatch/btUnionFind.h", "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h", - "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btCollisionObject.h", + "BulletCollision/CollisionDispatch/btCollisionWorld.h", "BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h", + "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h", "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h", + "BulletCollision/CollisionDispatch/btManifoldResult.h", + "BulletCollision/CollisionDispatch/btSimulationIslandManager.h", + "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btUnionFind.h", + "BulletCollision/CollisionShapes/btBox2dShape.h", + "BulletCollision/CollisionShapes/btBoxShape.h", + "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h", + "BulletCollision/CollisionShapes/btCapsuleShape.h", "BulletCollision/CollisionShapes/btCollisionShape.h", - "BulletCollision/CollisionShapes/btConvexShape.h", + "BulletCollision/CollisionShapes/btCompoundShape.h", + "BulletCollision/CollisionShapes/btConcaveShape.h", + "BulletCollision/CollisionShapes/btConeShape.h", + "BulletCollision/CollisionShapes/btConvex2dShape.h", + "BulletCollision/CollisionShapes/btConvexHullShape.h", + "BulletCollision/CollisionShapes/btConvexInternalShape.h", "BulletCollision/CollisionShapes/btConvexPolyhedron.h", + "BulletCollision/CollisionShapes/btConvexShape.h", + "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h", + "BulletCollision/CollisionShapes/btCylinderShape.h", + "BulletCollision/CollisionShapes/btEmptyShape.h", + "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h", + "BulletCollision/CollisionShapes/btMultiSphereShape.h", + "BulletCollision/CollisionShapes/btOptimizedBvh.h", "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h", - "BulletCollision/CollisionShapes/btConvexInternalShape.h", - "BulletCollision/CollisionShapes/btBoxShape.h", + "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h", + "BulletCollision/CollisionShapes/btSdfCollisionShape.h", + "BulletCollision/CollisionShapes/btShapeHull.h", "BulletCollision/CollisionShapes/btSphereShape.h", - "BulletCollision/CollisionShapes/btCapsuleShape.h", - "BulletCollision/CollisionShapes/btCylinderShape.h", - "BulletCollision/CollisionShapes/btConeShape.h", - "BulletCollision/CollisionShapes/btConcaveShape.h", - "BulletCollision/CollisionShapes/btTriangleCallback.h", "BulletCollision/CollisionShapes/btStaticPlaneShape.h", - "BulletCollision/CollisionShapes/btConvexHullShape.h", "BulletCollision/CollisionShapes/btStridingMeshInterface.h", + "BulletCollision/CollisionShapes/btTetrahedronShape.h", + "BulletCollision/CollisionShapes/btTriangleCallback.h", "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h", + "BulletCollision/CollisionShapes/btTriangleInfoMap.h", "BulletCollision/CollisionShapes/btTriangleMesh.h", - "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h", "BulletCollision/CollisionShapes/btTriangleMeshShape.h", - "BulletCollision/CollisionShapes/btOptimizedBvh.h", - "BulletCollision/CollisionShapes/btTriangleInfoMap.h", - "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h", - "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h", - "BulletCollision/CollisionShapes/btCompoundShape.h", - "BulletCollision/CollisionShapes/btTetrahedronShape.h", - "BulletCollision/CollisionShapes/btEmptyShape.h", - "BulletCollision/CollisionShapes/btMultiSphereShape.h", - "BulletCollision/CollisionShapes/btUniformScalingShape.h", - "BulletCollision/CollisionShapes/btBox2dShape.h", - "BulletCollision/CollisionShapes/btConvex2dShape.h", - "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h", "BulletCollision/CollisionShapes/btTriangleShape.h", - "BulletCollision/CollisionShapes/btSdfCollisionShape.h", - "BulletCollision/CollisionShapes/btShapeHull.h", + "BulletCollision/CollisionShapes/btUniformScalingShape.h", "BulletCollision/Gimpact/btGImpactShape.h", }, link = "BulletCollision@.3.20" diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index 7695cade467..e5a059ba554 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -40,52 +40,52 @@ @Platform( include = { "LinearMath/btAlignedObjectArray.h", - "BulletDynamics/Dynamics/btActionInterface.h", - "BulletDynamics/Dynamics/btRigidBody.h", - "BulletDynamics/Dynamics/btDynamicsWorld.h", - "BulletDynamics/ConstraintSolver/btContactSolverInfo.h", - "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h", - "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h", - "BulletDynamics/ConstraintSolver/btConstraintSolver.h", - "BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h", - "BulletDynamics/Dynamics/btSimulationIslandManagerMt.h", - "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h", - "BulletDynamics/ConstraintSolver/btHingeConstraint.h", + "BulletDynamics/ConstraintSolver/btBatchedConstraints.h", "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h", + "BulletDynamics/ConstraintSolver/btConstraintSolver.h", + "BulletDynamics/ConstraintSolver/btContactSolverInfo.h", + "BulletDynamics/ConstraintSolver/btFixedConstraint.h", + "BulletDynamics/ConstraintSolver/btGearConstraint.h", "BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h", - "BulletDynamics/ConstraintSolver/btSliderConstraint.h", - "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h", "BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h", - "BulletDynamics/ConstraintSolver/btUniversalConstraint.h", + "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h", "BulletDynamics/ConstraintSolver/btHinge2Constraint.h", - "BulletDynamics/ConstraintSolver/btGearConstraint.h", - "BulletDynamics/ConstraintSolver/btFixedConstraint.h", + "BulletDynamics/ConstraintSolver/btHingeConstraint.h", + "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h", + "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h", "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h", - "BulletDynamics/ConstraintSolver/btSolverConstraint.h", + "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h", + "BulletDynamics/ConstraintSolver/btSliderConstraint.h", "BulletDynamics/ConstraintSolver/btSolverBody.h", + "BulletDynamics/ConstraintSolver/btSolverConstraint.h", + "BulletDynamics/Dynamics/btRigidBody.h", "BulletDynamics/ConstraintSolver/btTypedConstraint.h", - "BulletDynamics/ConstraintSolver/btBatchedConstraints.h", - "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h", - "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h", + "BulletDynamics/ConstraintSolver/btUniversalConstraint.h", + "BulletDynamics/Dynamics/btActionInterface.h", + "BulletDynamics/Dynamics/btDynamicsWorld.h", + "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h", + "BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h", + "BulletDynamics/Dynamics/btSimpleDynamicsWorld.h", + "BulletDynamics/Dynamics/btSimulationIslandManagerMt.h", + "BulletDynamics/Vehicle/btRaycastVehicle.h", "BulletDynamics/Vehicle/btVehicleRaycaster.h", "BulletDynamics/Vehicle/btWheelInfo.h", - "BulletDynamics/Vehicle/btRaycastVehicle.h", - "BulletDynamics/Featherstone/btMultiBodyJointFeedback.h", - "BulletDynamics/Featherstone/btMultiBodyLink.h", "BulletDynamics/Featherstone/btMultiBody.h", - "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h", "BulletDynamics/Featherstone/btMultiBodyConstraint.h", - "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h", "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h", + "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h", "BulletDynamics/Featherstone/btMultiBodySolverConstraint.h", "BulletDynamics/Featherstone/btMultiBodyFixedConstraint.h", "BulletDynamics/Featherstone/btMultiBodyGearConstraint.h", + "BulletDynamics/Featherstone/btMultiBodyJointFeedback.h", "BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.h", "BulletDynamics/Featherstone/btMultiBodyJointMotor.h", + "BulletDynamics/Featherstone/btMultiBodyLink.h", + "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h", + "BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h", "BulletDynamics/Featherstone/btMultiBodyPoint2Point.h", "BulletDynamics/Featherstone/btMultiBodySliderConstraint.h", "BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h", - "BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h", "BulletDynamics/MLCPSolvers/btDantzigSolver.h", "BulletDynamics/MLCPSolvers/btLemkeSolver.h", "BulletDynamics/MLCPSolvers/btMLCPSolver.h", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 33a994df353..1108cc84527 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -43,19 +43,19 @@ @Platform( include = { "LinearMath/btAlignedObjectArray.h", - "BulletSoftBody/btSparseSDF.h", + "BulletSoftBody/btDeformableBackwardEulerObjective.h", + "BulletSoftBody/btDeformableBodySolver.h", + "BulletSoftBody/btDeformableLagrangianForce.h", + "BulletSoftBody/btDeformableMultiBodyConstraintSolver.h", + "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h", "BulletSoftBody/btSoftBody.h", - "BulletSoftBody/btSoftRigidDynamicsWorld.h", "BulletSoftBody/btSoftBodyHelpers.h", "BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h", + "BulletSoftBody/btSoftBodySolverVertexBuffer.h", "BulletSoftBody/btSoftBodySolvers.h", "BulletSoftBody/btSoftMultiBodyDynamicsWorld.h", - "BulletSoftBody/btDeformableBodySolver.h", - "BulletSoftBody/btDeformableMultiBodyConstraintSolver.h", - "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h", - "BulletSoftBody/btSoftBodySolverVertexBuffer.h", - "BulletSoftBody/btDeformableBackwardEulerObjective.h", - "BulletSoftBody/btDeformableLagrangianForce.h", + "BulletSoftBody/btSoftRigidDynamicsWorld.h", + "BulletSoftBody/btSparseSDF.h", }, link = "BulletSoftBody@.3.20" ) From 2441b9402f970d96b06efc84b37b2e4a792f93f6 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 9 Mar 2022 22:48:52 +0800 Subject: [PATCH 49/81] Update generated code for bullet's preset See parent commit. --- .../bullet/global/BulletCollision.java | 2336 ++++++++--------- .../bullet/global/BulletDynamics.java | 1518 +++++------ .../bullet/global/BulletSoftBody.java | 452 ++-- 3 files changed, 2153 insertions(+), 2153 deletions(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index c4b0ca9f004..7df9509b723 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -74,6 +74,211 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #endif //BT_OBJECT_ARRAY__ +// Parsed from BulletCollision/BroadphaseCollision/btAxisSweep3.h + +//Bullet Continuous Collision Detection and Physics Library +//Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +// +// btAxisSweep3.h +// +// Copyright (c) 2006 Simon Hobbs +// +// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. + +// #ifndef BT_AXIS_SWEEP_3_H +// #define BT_AXIS_SWEEP_3_H + +// #include "LinearMath/btVector3.h" +// #include "btOverlappingPairCache.h" +// #include "btBroadphaseInterface.h" +// #include "btBroadphaseProxy.h" +// #include "btOverlappingPairCallback.h" +// #include "btDbvtBroadphase.h" +// #include "btAxisSweep3Internal.h" +// Targeting ../BulletCollision/btAxisSweep3.java + + +// Targeting ../BulletCollision/bt32BitAxisSweep3.java + + + +// #endif + + +// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BROADPHASE_INTERFACE_H +// #define BT_BROADPHASE_INTERFACE_H +// #include "btBroadphaseProxy.h" +// Targeting ../BulletCollision/btBroadphaseAabbCallback.java + + +// Targeting ../BulletCollision/btBroadphaseRayCallback.java + + + +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btBroadphaseInterface.java + + + +// #endif //BT_BROADPHASE_INTERFACE_H + + +// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseProxy.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BROADPHASE_PROXY_H +// #define BT_BROADPHASE_PROXY_H + +// #include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedAllocator.h" + +/** btDispatcher uses these types + * IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave + * to facilitate type checking + * CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code */ +/** enum BroadphaseNativeTypes */ +public static final int + // polyhedral convex shapes + BOX_SHAPE_PROXYTYPE = 0, + TRIANGLE_SHAPE_PROXYTYPE = 1, + TETRAHEDRAL_SHAPE_PROXYTYPE = 2, + CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE = 3, + CONVEX_HULL_SHAPE_PROXYTYPE = 4, + CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE = 5, + CUSTOM_POLYHEDRAL_SHAPE_TYPE = 6, + //implicit convex shapes + IMPLICIT_CONVEX_SHAPES_START_HERE = 7, + SPHERE_SHAPE_PROXYTYPE = 8, + MULTI_SPHERE_SHAPE_PROXYTYPE = 9, + CAPSULE_SHAPE_PROXYTYPE = 10, + CONE_SHAPE_PROXYTYPE = 11, + CONVEX_SHAPE_PROXYTYPE = 12, + CYLINDER_SHAPE_PROXYTYPE = 13, + UNIFORM_SCALING_SHAPE_PROXYTYPE = 14, + MINKOWSKI_SUM_SHAPE_PROXYTYPE = 15, + MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE = 16, + BOX_2D_SHAPE_PROXYTYPE = 17, + CONVEX_2D_SHAPE_PROXYTYPE = 18, + CUSTOM_CONVEX_SHAPE_TYPE = 19, + //concave shapes + CONCAVE_SHAPES_START_HERE = 20, + //keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy! + TRIANGLE_MESH_SHAPE_PROXYTYPE = 21, + SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE = 22, + /**used for demo integration FAST/Swift collision library and Bullet */ + FAST_CONCAVE_MESH_PROXYTYPE = 23, + //terrain + TERRAIN_SHAPE_PROXYTYPE = 24, + /**Used for GIMPACT Trimesh integration */ + GIMPACT_SHAPE_PROXYTYPE = 25, + /**Multimaterial mesh */ + MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE = 26, + + EMPTY_SHAPE_PROXYTYPE = 27, + STATIC_PLANE_PROXYTYPE = 28, + CUSTOM_CONCAVE_SHAPE_TYPE = 29, + SDF_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE, + CONCAVE_SHAPES_END_HERE = CUSTOM_CONCAVE_SHAPE_TYPE + 1, + + COMPOUND_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 2, + + SOFTBODY_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 3, + HFFLUID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 4, + HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 5, + INVALID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 6, + + MAX_BROADPHASE_COLLISION_TYPES = CUSTOM_CONCAVE_SHAPE_TYPE + 7; +// Targeting ../BulletCollision/btBroadphaseProxy.java + + +// Targeting ../BulletCollision/btBroadphasePair.java + + +// Targeting ../BulletCollision/btBroadphasePairSortPredicate.java + + + +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btBroadphasePair a, @Const @ByRef btBroadphasePair b); + +// #endif //BT_BROADPHASE_PROXY_H + + +// Parsed from BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_COLLISION_ALGORITHM_H +// #define BT_COLLISION_ALGORITHM_H + +// #include "LinearMath/btScalar.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btCollisionObjectWrapper.java + + +// Targeting ../BulletCollision/btCollisionAlgorithmConstructionInfo.java + + +// Targeting ../BulletCollision/btCollisionAlgorithm.java + + + +// #endif //BT_COLLISION_ALGORITHM_H + + // Parsed from BulletCollision/BroadphaseCollision/btDbvt.h /* @@ -306,11 +511,11 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, // #endif -// Parsed from BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h +// Parsed from BulletCollision/BroadphaseCollision/btDbvtBroadphase.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -323,25 +528,40 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_COLLISION_ALGORITHM_H -// #define BT_COLLISION_ALGORITHM_H +/**btDbvtBroadphase implementation by Nathanael Presson */ +// #ifndef BT_DBVT_BROADPHASE_H +// #define BT_DBVT_BROADPHASE_H -// #include "LinearMath/btScalar.h" -// #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btCollisionObjectWrapper.java +// #include "BulletCollision/BroadphaseCollision/btDbvt.h" +// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +// +// Compile time config +// -// Targeting ../BulletCollision/btCollisionAlgorithmConstructionInfo.java +public static native @MemberGetter int DBVT_BP_PROFILE(); +public static final int DBVT_BP_PROFILE = DBVT_BP_PROFILE(); +//#define DBVT_BP_SORTPAIRS 1 +public static final int DBVT_BP_PREVENTFALSEUPDATE = 0; +public static final int DBVT_BP_ACCURATESLEEPING = 0; +public static final int DBVT_BP_ENABLE_BENCHMARK = 0; +//#define DBVT_BP_MARGIN (btScalar)0.05 +public static native @Cast("btScalar") float gDbvtMargin(); public static native void gDbvtMargin(float setter); +// #if DBVT_BP_PROFILE +// #endif -// Targeting ../BulletCollision/btCollisionAlgorithm.java +// +// btDbvtProxy +// +// Targeting ../BulletCollision/btDbvtBroadphase.java -// #endif //BT_COLLISION_ALGORITHM_H +// #endif -// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseProxy.h +// Parsed from BulletCollision/BroadphaseCollision/btDispatcher.h /* Bullet Continuous Collision Detection and Physics Library @@ -358,105 +578,10 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_BROADPHASE_PROXY_H -// #define BT_BROADPHASE_PROXY_H - -// #include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btAlignedAllocator.h" - -/** btDispatcher uses these types - * IMPORTANT NOTE:The types are ordered polyhedral, implicit convex and concave - * to facilitate type checking - * CUSTOM_POLYHEDRAL_SHAPE_TYPE,CUSTOM_CONVEX_SHAPE_TYPE and CUSTOM_CONCAVE_SHAPE_TYPE can be used to extend Bullet without modifying source code */ -/** enum BroadphaseNativeTypes */ -public static final int - // polyhedral convex shapes - BOX_SHAPE_PROXYTYPE = 0, - TRIANGLE_SHAPE_PROXYTYPE = 1, - TETRAHEDRAL_SHAPE_PROXYTYPE = 2, - CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE = 3, - CONVEX_HULL_SHAPE_PROXYTYPE = 4, - CONVEX_POINT_CLOUD_SHAPE_PROXYTYPE = 5, - CUSTOM_POLYHEDRAL_SHAPE_TYPE = 6, - //implicit convex shapes - IMPLICIT_CONVEX_SHAPES_START_HERE = 7, - SPHERE_SHAPE_PROXYTYPE = 8, - MULTI_SPHERE_SHAPE_PROXYTYPE = 9, - CAPSULE_SHAPE_PROXYTYPE = 10, - CONE_SHAPE_PROXYTYPE = 11, - CONVEX_SHAPE_PROXYTYPE = 12, - CYLINDER_SHAPE_PROXYTYPE = 13, - UNIFORM_SCALING_SHAPE_PROXYTYPE = 14, - MINKOWSKI_SUM_SHAPE_PROXYTYPE = 15, - MINKOWSKI_DIFFERENCE_SHAPE_PROXYTYPE = 16, - BOX_2D_SHAPE_PROXYTYPE = 17, - CONVEX_2D_SHAPE_PROXYTYPE = 18, - CUSTOM_CONVEX_SHAPE_TYPE = 19, - //concave shapes - CONCAVE_SHAPES_START_HERE = 20, - //keep all the convex shapetype below here, for the check IsConvexShape in broadphase proxy! - TRIANGLE_MESH_SHAPE_PROXYTYPE = 21, - SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE = 22, - /**used for demo integration FAST/Swift collision library and Bullet */ - FAST_CONCAVE_MESH_PROXYTYPE = 23, - //terrain - TERRAIN_SHAPE_PROXYTYPE = 24, - /**Used for GIMPACT Trimesh integration */ - GIMPACT_SHAPE_PROXYTYPE = 25, - /**Multimaterial mesh */ - MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE = 26, - - EMPTY_SHAPE_PROXYTYPE = 27, - STATIC_PLANE_PROXYTYPE = 28, - CUSTOM_CONCAVE_SHAPE_TYPE = 29, - SDF_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE, - CONCAVE_SHAPES_END_HERE = CUSTOM_CONCAVE_SHAPE_TYPE + 1, - - COMPOUND_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 2, - - SOFTBODY_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 3, - HFFLUID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 4, - HFFLUID_BUOYANT_CONVEX_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 5, - INVALID_SHAPE_PROXYTYPE = CUSTOM_CONCAVE_SHAPE_TYPE + 6, - - MAX_BROADPHASE_COLLISION_TYPES = CUSTOM_CONCAVE_SHAPE_TYPE + 7; -// Targeting ../BulletCollision/btBroadphaseProxy.java - - -// Targeting ../BulletCollision/btBroadphasePair.java - - -// Targeting ../BulletCollision/btBroadphasePairSortPredicate.java - - - -public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btBroadphasePair a, @Const @ByRef btBroadphasePair b); - -// #endif //BT_BROADPHASE_PROXY_H - - -// Parsed from BulletCollision/BroadphaseCollision/btDispatcher.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_DISPATCHER_H -// #define BT_DISPATCHER_H -// #include "LinearMath/btScalar.h" -// Targeting ../BulletCollision/btDispatcherInfo.java +// #ifndef BT_DISPATCHER_H +// #define BT_DISPATCHER_H +// #include "LinearMath/btScalar.h" +// Targeting ../BulletCollision/btDispatcherInfo.java @@ -471,33 +596,6 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, // #endif //BT_DISPATCHER_H -// Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h - - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef OVERLAPPING_PAIR_CALLBACK_H -// #define OVERLAPPING_PAIR_CALLBACK_H -// Targeting ../BulletCollision/btOverlappingPairCallback.java - - - -// #endif //OVERLAPPING_PAIR_CALLBACK_H - - // Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCache.h /* @@ -547,6 +645,33 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, // #endif //BT_OVERLAPPING_PAIR_CACHE_H +// Parsed from BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h + + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef OVERLAPPING_PAIR_CALLBACK_H +// #define OVERLAPPING_PAIR_CALLBACK_H +// Targeting ../BulletCollision/btOverlappingPairCallback.java + + + +// #endif //OVERLAPPING_PAIR_CALLBACK_H + + // Parsed from BulletCollision/BroadphaseCollision/btQuantizedBvh.h /* @@ -639,7 +764,7 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, // #endif //BT_QUANTIZED_BVH_H -// Parsed from BulletCollision/BroadphaseCollision/btBroadphaseInterface.h +// Parsed from BulletCollision/BroadphaseCollision/btSimpleBroadphase.h /* Bullet Continuous Collision Detection and Physics Library @@ -656,25 +781,21 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_BROADPHASE_INTERFACE_H -// #define BT_BROADPHASE_INTERFACE_H -// #include "btBroadphaseProxy.h" -// Targeting ../BulletCollision/btBroadphaseAabbCallback.java - - -// Targeting ../BulletCollision/btBroadphaseRayCallback.java +// #ifndef BT_SIMPLE_BROADPHASE_H +// #define BT_SIMPLE_BROADPHASE_H +// #include "btOverlappingPairCache.h" +// Targeting ../BulletCollision/btSimpleBroadphaseProxy.java -// #include "LinearMath/btVector3.h" -// Targeting ../BulletCollision/btBroadphaseInterface.java +// Targeting ../BulletCollision/btSimpleBroadphase.java -// #endif //BT_BROADPHASE_INTERFACE_H +// #endif //BT_SIMPLE_BROADPHASE_H -// Parsed from BulletCollision/BroadphaseCollision/btSimpleBroadphase.h +// Parsed from BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h /* Bullet Continuous Collision Detection and Physics Library @@ -691,65 +812,63 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SIMPLE_BROADPHASE_H -// #define BT_SIMPLE_BROADPHASE_H - -// #include "btOverlappingPairCache.h" -// Targeting ../BulletCollision/btSimpleBroadphaseProxy.java +// #ifndef BT_CONTINUOUS_COLLISION_CONVEX_CAST_H +// #define BT_CONTINUOUS_COLLISION_CONVEX_CAST_H +// #include "btConvexCast.h" +// #include "btSimplexSolverInterface.h" +// Targeting ../BulletCollision/btContinuousConvexCollision.java -// Targeting ../BulletCollision/btSimpleBroadphase.java +// #endif //BT_CONTINUOUS_COLLISION_CONVEX_CAST_H -// #endif //BT_SIMPLE_BROADPHASE_H +// Parsed from BulletCollision/NarrowPhaseCollision/btConvexCast.h -// Parsed from BulletCollision/BroadphaseCollision/btAxisSweep3.h +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org -//Bullet Continuous Collision Detection and Physics Library -//Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: -// -// btAxisSweep3.h -// -// Copyright (c) 2006 Simon Hobbs -// -// This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ -// #ifndef BT_AXIS_SWEEP_3_H -// #define BT_AXIS_SWEEP_3_H +// #ifndef BT_CONVEX_CAST_H +// #define BT_CONVEX_CAST_H +// #include "LinearMath/btTransform.h" // #include "LinearMath/btVector3.h" -// #include "btOverlappingPairCache.h" -// #include "btBroadphaseInterface.h" -// #include "btBroadphaseProxy.h" -// #include "btOverlappingPairCallback.h" -// #include "btDbvtBroadphase.h" -// #include "btAxisSweep3Internal.h" -// Targeting ../BulletCollision/btAxisSweep3.java +// #include "LinearMath/btScalar.h" +// Targeting ../BulletCollision/btMinkowskiSumShape.java -// Targeting ../BulletCollision/bt32BitAxisSweep3.java +// #include "LinearMath/btIDebugDraw.h" + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +public static final int MAX_CONVEX_CAST_ITERATIONS = 32; +public static native @MemberGetter double MAX_CONVEX_CAST_EPSILON(); +public static final double MAX_CONVEX_CAST_EPSILON = MAX_CONVEX_CAST_EPSILON(); +// Targeting ../BulletCollision/btConvexCast.java -// #endif +// #endif //BT_CONVEX_CAST_H -// Parsed from BulletCollision/BroadphaseCollision/btDbvtBroadphase.h +// Parsed from BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -762,315 +881,16 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, 3. This notice may not be removed or altered from any source distribution. */ -/**btDbvtBroadphase implementation by Nathanael Presson */ -// #ifndef BT_DBVT_BROADPHASE_H -// #define BT_DBVT_BROADPHASE_H +// #ifndef BT_CONVEX_PENETRATION_DEPTH_H +// #define BT_CONVEX_PENETRATION_DEPTH_H +// #include "btSimplexSolverInterface.h" +// Targeting ../BulletCollision/btConvexPenetrationDepthSolver.java -// #include "BulletCollision/BroadphaseCollision/btDbvt.h" -// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" -// -// Compile time config -// +// #endif //BT_CONVEX_PENETRATION_DEPTH_H -public static native @MemberGetter int DBVT_BP_PROFILE(); -public static final int DBVT_BP_PROFILE = DBVT_BP_PROFILE(); -//#define DBVT_BP_SORTPAIRS 1 -public static final int DBVT_BP_PREVENTFALSEUPDATE = 0; -public static final int DBVT_BP_ACCURATESLEEPING = 0; -public static final int DBVT_BP_ENABLE_BENCHMARK = 0; -//#define DBVT_BP_MARGIN (btScalar)0.05 -public static native @Cast("btScalar") float gDbvtMargin(); public static native void gDbvtMargin(float setter); -// #if DBVT_BP_PROFILE -// #endif - -// -// btDbvtProxy -// -// Targeting ../BulletCollision/btDbvtBroadphase.java - - - -// #endif - - -// Parsed from BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_SIMPLEX_SOLVER_INTERFACE_H -// #define BT_SIMPLEX_SOLVER_INTERFACE_H - -// #include "LinearMath/btVector3.h" - -public static native @MemberGetter int NO_VIRTUAL_INTERFACE(); -public static final int NO_VIRTUAL_INTERFACE = NO_VIRTUAL_INTERFACE(); -// Targeting ../BulletCollision/btSimplexSolverInterface.java - - -// #endif -// #endif //BT_SIMPLEX_SOLVER_INTERFACE_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_VORONOI_SIMPLEX_SOLVER_H -// #define BT_VORONOI_SIMPLEX_SOLVER_H - -// #include "btSimplexSolverInterface.h" - -public static final int VORONOI_SIMPLEX_MAX_VERTS = 5; - -/**disable next define, or use defaultCollisionConfiguration->getSimplexSolver()->setEqualVertexThreshold(0.f) to disable/configure */ -// #define BT_USE_EQUAL_VERTEX_THRESHOLD - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -public static final double VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD = 0.0001f; -// Targeting ../BulletCollision/btUsageBitfield.java - - -// Targeting ../BulletCollision/btSubSimplexClosestResult.java - - -// Targeting ../BulletCollision/btVoronoiSimplexSolver.java - - - -// #endif //BT_VORONOI_SIMPLEX_SOLVER_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_CONVEX_PENETRATION_DEPTH_H -// #define BT_CONVEX_PENETRATION_DEPTH_H -// #include "btSimplexSolverInterface.h" -// Targeting ../BulletCollision/btConvexPenetrationDepthSolver.java - - -// #endif //BT_CONVEX_PENETRATION_DEPTH_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btManifoldPoint.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_MANIFOLD_CONTACT_POINT_H -// #define BT_MANIFOLD_CONTACT_POINT_H - -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransformUtil.h" -// Targeting ../BulletCollision/btConstraintRow.java - - -// #endif //PFX_USE_FREE_VECTORMATH - -/** enum btContactPointFlags */ -public static final int - BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED = 1, - BT_CONTACT_FLAG_HAS_CONTACT_CFM = 2, - BT_CONTACT_FLAG_HAS_CONTACT_ERP = 4, - BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING = 8, - BT_CONTACT_FLAG_FRICTION_ANCHOR = 16; -// Targeting ../BulletCollision/btManifoldPoint.java - - - -// #endif //BT_MANIFOLD_CONTACT_POINT_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H -// #define BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H - -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btVector3.h" -// Targeting ../BulletCollision/btDiscreteCollisionDetectorInterface.java - - -// Targeting ../BulletCollision/btStorageResult.java - - - -// #endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btPersistentManifold.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_PERSISTENT_MANIFOLD_H -// #define BT_PERSISTENT_MANIFOLD_H - -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "btManifoldPoint.h" -// #include "LinearMath/btAlignedAllocator.h" - -/**maximum contact breaking and merging threshold */ -public static native @Cast("btScalar") float gContactBreakingThreshold(); public static native void gContactBreakingThreshold(float setter); -// Targeting ../BulletCollision/ContactDestroyedCallback.java - - -// Targeting ../BulletCollision/ContactProcessedCallback.java - - -// Targeting ../BulletCollision/ContactStartedCallback.java - - -// Targeting ../BulletCollision/ContactEndedCallback.java - - - - - - -// #endif //SWIG - -//the enum starts at 1024 to avoid type conflicts with btTypedConstraint -/** enum btContactManifoldTypes */ -public static final int - MIN_CONTACT_MANIFOLD_TYPE = 1024, - BT_PERSISTENT_MANIFOLD_TYPE = 1025; - -public static final int MANIFOLD_CACHE_SIZE = 4; -// Targeting ../BulletCollision/btPersistentManifold.java - - -// Targeting ../BulletCollision/btPersistentManifoldDoubleData.java - - -// Targeting ../BulletCollision/btPersistentManifoldFloatData.java - - - -// clang-format on - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btPersistentManifoldData btPersistentManifoldFloatData -public static final String btPersistentManifoldDataName = "btPersistentManifoldFloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -// #endif //BT_PERSISTENT_MANIFOLD_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -EPA Copyright (c) Ricardo Padrela 2006 - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ -// #ifndef BT_GJP_EPA_PENETRATION_DEPTH_H -// #define BT_GJP_EPA_PENETRATION_DEPTH_H - -// #include "btConvexPenetrationDepthSolver.h" -// Targeting ../BulletCollision/btGjkEpaPenetrationDepthSolver.java - - - -// #endif // BT_GJP_EPA_PENETRATION_DEPTH_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btConvexCast.h +// Parsed from BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h /* Bullet Continuous Collision Detection and Physics Library @@ -1087,56 +907,19 @@ EPA Copyright (c) Ricardo Padrela 2006 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_CAST_H -// #define BT_CONVEX_CAST_H +// #ifndef BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H +// #define BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H // #include "LinearMath/btTransform.h" // #include "LinearMath/btVector3.h" -// #include "LinearMath/btScalar.h" -// Targeting ../BulletCollision/btMinkowskiSumShape.java - - -// #include "LinearMath/btIDebugDraw.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -public static final int MAX_CONVEX_CAST_ITERATIONS = 32; -public static native @MemberGetter double MAX_CONVEX_CAST_EPSILON(); -public static final double MAX_CONVEX_CAST_EPSILON = MAX_CONVEX_CAST_EPSILON(); -// Targeting ../BulletCollision/btConvexCast.java - - - -// #endif //BT_CONVEX_CAST_H - - -// Parsed from BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ +// Targeting ../BulletCollision/btDiscreteCollisionDetectorInterface.java -// #ifndef BT_CONTINUOUS_COLLISION_CONVEX_CAST_H -// #define BT_CONTINUOUS_COLLISION_CONVEX_CAST_H -// #include "btConvexCast.h" -// #include "btSimplexSolverInterface.h" -// Targeting ../BulletCollision/btContinuousConvexCollision.java +// Targeting ../BulletCollision/btStorageResult.java -// #endif //BT_CONTINUOUS_COLLISION_CONVEX_CAST_H +// #endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H // Parsed from BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h @@ -1327,6 +1110,35 @@ EPA Copyright (c) Ricardo Padrela 2006 // #endif //BT_GJK_EPA3_H +// Parsed from BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +EPA Copyright (c) Ricardo Padrela 2006 + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_GJP_EPA_PENETRATION_DEPTH_H +// #define BT_GJP_EPA_PENETRATION_DEPTH_H + +// #include "btConvexPenetrationDepthSolver.h" +// Targeting ../BulletCollision/btGjkEpaPenetrationDepthSolver.java + + + +// #endif // BT_GJP_EPA_PENETRATION_DEPTH_H + + // Parsed from BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h /* @@ -1357,6 +1169,47 @@ EPA Copyright (c) Ricardo Padrela 2006 // #endif //BT_GJK_PAIR_DETECTOR_H +// Parsed from BulletCollision/NarrowPhaseCollision/btManifoldPoint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MANIFOLD_CONTACT_POINT_H +// #define BT_MANIFOLD_CONTACT_POINT_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransformUtil.h" +// Targeting ../BulletCollision/btConstraintRow.java + + +// #endif //PFX_USE_FREE_VECTORMATH + +/** enum btContactPointFlags */ +public static final int + BT_CONTACT_FLAG_LATERAL_FRICTION_INITIALIZED = 1, + BT_CONTACT_FLAG_HAS_CONTACT_CFM = 2, + BT_CONTACT_FLAG_HAS_CONTACT_ERP = 4, + BT_CONTACT_FLAG_CONTACT_STIFFNESS_DAMPING = 8, + BT_CONTACT_FLAG_FRICTION_ANCHOR = 16; +// Targeting ../BulletCollision/btManifoldPoint.java + + + +// #endif //BT_MANIFOLD_CONTACT_POINT_H + + // Parsed from BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h /* @@ -1529,11 +1382,148 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_MPR_PENETRATION_H -// Parsed from BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h +// Parsed from BulletCollision/NarrowPhaseCollision/btPersistentManifold.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_PERSISTENT_MANIFOLD_H +// #define BT_PERSISTENT_MANIFOLD_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "btManifoldPoint.h" +// #include "LinearMath/btAlignedAllocator.h" + +/**maximum contact breaking and merging threshold */ +public static native @Cast("btScalar") float gContactBreakingThreshold(); public static native void gContactBreakingThreshold(float setter); +// Targeting ../BulletCollision/ContactDestroyedCallback.java + + +// Targeting ../BulletCollision/ContactProcessedCallback.java + + +// Targeting ../BulletCollision/ContactStartedCallback.java + + +// Targeting ../BulletCollision/ContactEndedCallback.java + + + + + + +// #endif //SWIG + +//the enum starts at 1024 to avoid type conflicts with btTypedConstraint +/** enum btContactManifoldTypes */ +public static final int + MIN_CONTACT_MANIFOLD_TYPE = 1024, + BT_PERSISTENT_MANIFOLD_TYPE = 1025; + +public static final int MANIFOLD_CACHE_SIZE = 4; +// Targeting ../BulletCollision/btPersistentManifold.java + + +// Targeting ../BulletCollision/btPersistentManifoldDoubleData.java + + +// Targeting ../BulletCollision/btPersistentManifoldFloatData.java + + + +// clang-format on + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btPersistentManifoldData btPersistentManifoldFloatData +public static final String btPersistentManifoldDataName = "btPersistentManifoldFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +// #endif //BT_PERSISTENT_MANIFOLD_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was written by Erwin Coumans */ + +// #ifndef BT_POLYHEDRAL_CONTACT_CLIPPING_H +// #define BT_POLYHEDRAL_CONTACT_CLIPPING_H + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btTransform.h" +// #include "btDiscreteCollisionDetectorInterface.h" +// Targeting ../BulletCollision/btPolyhedralContactClipping.java + + + +// #endif // BT_POLYHEDRAL_CONTACT_CLIPPING_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btRaycastCallback.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_RAYCAST_TRI_CALLBACK_H +// #define BT_RAYCAST_TRI_CALLBACK_H + +// #include "BulletCollision/CollisionShapes/btTriangleCallback.h" +// #include "LinearMath/btTransform.h" +// Targeting ../BulletCollision/btTriangleRaycastCallback.java + + +// Targeting ../BulletCollision/btTriangleConvexcastCallback.java + + + +// #endif //BT_RAYCAST_TRI_CALLBACK_H + + +// Parsed from BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1546,19 +1536,18 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -/**This file was written by Erwin Coumans */ - -// #ifndef BT_POLYHEDRAL_CONTACT_CLIPPING_H -// #define BT_POLYHEDRAL_CONTACT_CLIPPING_H +// #ifndef BT_SIMPLEX_SOLVER_INTERFACE_H +// #define BT_SIMPLEX_SOLVER_INTERFACE_H -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btTransform.h" -// #include "btDiscreteCollisionDetectorInterface.h" -// Targeting ../BulletCollision/btPolyhedralContactClipping.java +// #include "LinearMath/btVector3.h" +public static native @MemberGetter int NO_VIRTUAL_INTERFACE(); +public static final int NO_VIRTUAL_INTERFACE = NO_VIRTUAL_INTERFACE(); +// Targeting ../BulletCollision/btSimplexSolverInterface.java -// #endif // BT_POLYHEDRAL_CONTACT_CLIPPING_H +// #endif +// #endif //BT_SIMPLEX_SOLVER_INTERFACE_H // Parsed from BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h @@ -1590,7 +1579,7 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_SUBSIMPLEX_CONVEX_CAST_H -// Parsed from BulletCollision/NarrowPhaseCollision/btRaycastCallback.h +// Parsed from BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h /* Bullet Continuous Collision Detection and Physics Library @@ -1607,26 +1596,37 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_RAYCAST_TRI_CALLBACK_H -// #define BT_RAYCAST_TRI_CALLBACK_H +// #ifndef BT_VORONOI_SIMPLEX_SOLVER_H +// #define BT_VORONOI_SIMPLEX_SOLVER_H -// #include "BulletCollision/CollisionShapes/btTriangleCallback.h" -// #include "LinearMath/btTransform.h" -// Targeting ../BulletCollision/btTriangleRaycastCallback.java +// #include "btSimplexSolverInterface.h" + +public static final int VORONOI_SIMPLEX_MAX_VERTS = 5; +/**disable next define, or use defaultCollisionConfiguration->getSimplexSolver()->setEqualVertexThreshold(0.f) to disable/configure */ +// #define BT_USE_EQUAL_VERTEX_THRESHOLD -// Targeting ../BulletCollision/btTriangleConvexcastCallback.java +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +public static final double VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD = 0.0001f; +// Targeting ../BulletCollision/btUsageBitfield.java +// Targeting ../BulletCollision/btSubSimplexClosestResult.java -// #endif //BT_RAYCAST_TRI_CALLBACK_H +// Targeting ../BulletCollision/btVoronoiSimplexSolver.java + + + +// #endif //BT_VORONOI_SIMPLEX_SOLVER_H -// Parsed from BulletCollision/CollisionDispatch/btCollisionConfiguration.h + +// Parsed from BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1639,16 +1639,17 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_COLLISION_CONFIGURATION -// #define BT_COLLISION_CONFIGURATION -// Targeting ../BulletCollision/btCollisionConfiguration.java +// #ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H +// #define __BT_ACTIVATING_COLLISION_ALGORITHM_H +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// Targeting ../BulletCollision/btActivatingCollisionAlgorithm.java -// #endif //BT_COLLISION_CONFIGURATION +// #endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btCollisionObject.h +// Parsed from BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -1665,40 +1666,44 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_COLLISION_OBJECT_H -// #define BT_COLLISION_OBJECT_H +// #ifndef BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H +// #define BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H -// #include "LinearMath/btTransform.h" +// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// Targeting ../BulletCollision/btBox2dBox2dCollisionAlgorithm.java -//island management, m_activationState1 -public static final int ACTIVE_TAG = 1; -public static final int ISLAND_SLEEPING = 2; -public static final int WANTS_DEACTIVATION = 3; -public static final int DISABLE_DEACTIVATION = 4; -public static final int DISABLE_SIMULATION = 5; -public static final int FIXED_BASE_MULTI_BODY = 6; -// #include "LinearMath/btMotionState.h" -// #include "LinearMath/btAlignedAllocator.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btCollisionObjectData btCollisionObjectFloatData -public static final String btCollisionObjectDataName = "btCollisionObjectFloatData"; -// Targeting ../BulletCollision/btCollisionObject.java +// #endif //BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H -// Targeting ../BulletCollision/btCollisionObjectDoubleData.java +// Parsed from BulletCollision/CollisionDispatch/btCollisionConfiguration.h -// Targeting ../BulletCollision/btCollisionObjectFloatData.java +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ -// clang-format on +// #ifndef BT_COLLISION_CONFIGURATION +// #define BT_COLLISION_CONFIGURATION +// Targeting ../BulletCollision/btCollisionConfiguration.java -// #endif //BT_COLLISION_OBJECT_H +// #endif //BT_COLLISION_CONFIGURATION // Parsed from BulletCollision/CollisionDispatch/btCollisionCreateFunc.h @@ -1769,11 +1774,11 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_COLLISION__DISPATCHER_H -// Parsed from BulletCollision/CollisionDispatch/btCollisionWorld.h +// Parsed from BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1786,76 +1791,19 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -/** - * \mainpage Bullet Documentation - * - * \section intro_sec Introduction - * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ). - * - * The main documentation is Bullet_User_Manual.pdf, included in the source code distribution. - * There is the Physics Forum for feedback and general Collision Detection and Physics discussions. - * Please visit http://www.bulletphysics.org - * - * \section install_sec Installation - * - * \subsection step1 Step 1: Download - * You can download the Bullet Physics Library from the github repository: https://github.com/bulletphysics/bullet3/releases - * - * \subsection step2 Step 2: Building - * Bullet has multiple build systems, including premake, cmake and autotools. Premake and cmake support all platforms. - * Premake is included in the Bullet/build folder for Windows, Mac OSX and Linux. - * Under Windows you can click on Bullet/build/vs2010.bat to create Microsoft Visual Studio projects. - * On Mac OSX and Linux you can open a terminal and generate Makefile, codeblocks or Xcode4 projects: - * cd Bullet/build - * ./premake4_osx gmake or ./premake4_linux gmake or ./premake4_linux64 gmake or (for Mac) ./premake4_osx xcode4 - * cd Bullet/build/gmake - * make - * - * An alternative to premake is cmake. You can download cmake from http://www.cmake.org - * cmake can autogenerate projectfiles for Microsoft Visual Studio, Apple Xcode, KDevelop and Unix Makefiles. - * The easiest is to run the CMake cmake-gui graphical user interface and choose the options and generate projectfiles. - * You can also use cmake in the command-line. Here are some examples for various platforms: - * cmake . -G "Visual Studio 9 2008" - * cmake . -G Xcode - * cmake . -G "Unix Makefiles" - * Although cmake is recommended, you can also use autotools for UNIX: ./autogen.sh ./configure to create a Makefile and then run make. - * - * \subsection step3 Step 3: Testing demos - * Try to run and experiment with BasicDemo executable as a starting point. - * Bullet can be used in several ways, as Full Rigid Body simulation, as Collision Detector Library or Low Level / Snippets like the GJK Closest Point calculation. - * The Dependencies can be seen in this documentation under Directories - * - * \subsection step4 Step 4: Integrating in your application, full Rigid Body and Soft Body simulation - * Check out BasicDemo how to create a btDynamicsWorld, btRigidBody and btCollisionShape, Stepping the simulation and synchronizing your graphics object transform. - * Check out SoftDemo how to use soft body dynamics, using btSoftRigidDynamicsWorld. - * \subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras) - * Bullet Collision Detection can also be used without the Dynamics/Extras. - * Check out btCollisionWorld and btCollisionObject, and the CollisionInterfaceDemo. - * \subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation. - * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of btGjkPairDetector. - * - * \section copyright Copyright - * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf - * - */ - -// #ifndef BT_COLLISION_WORLD_H -// #define BT_COLLISION_WORLD_H +// #ifndef BT_COLLISION_DISPATCHER_MT_H +// #define BT_COLLISION_DISPATCHER_MT_H -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "btCollisionObject.h" -// #include "btCollisionDispatcher.h" -// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" -// #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btCollisionWorld.java +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +// #include "LinearMath/btThreads.h" +// Targeting ../BulletCollision/btCollisionDispatcherMt.java -// #endif //BT_COLLISION_WORLD_H +// #endif //BT_COLLISION_DISPATCHER_MT_H -// Parsed from BulletCollision/CollisionDispatch/btManifoldResult.h +// Parsed from BulletCollision/CollisionDispatch/btCollisionObject.h /* Bullet Continuous Collision Detection and Physics Library @@ -1872,42 +1820,47 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_MANIFOLD_RESULT_H -// #define BT_MANIFOLD_RESULT_H +// #ifndef BT_COLLISION_OBJECT_H +// #define BT_COLLISION_OBJECT_H -// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "LinearMath/btTransform.h" -// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" +//island management, m_activationState1 +public static final int ACTIVE_TAG = 1; +public static final int ISLAND_SLEEPING = 2; +public static final int WANTS_DEACTIVATION = 3; +public static final int DISABLE_DEACTIVATION = 4; +public static final int DISABLE_SIMULATION = 5; +public static final int FIXED_BASE_MULTI_BODY = 6; +// #include "LinearMath/btMotionState.h" +// #include "LinearMath/btAlignedAllocator.h" +// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btTransform.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" -// Targeting ../BulletCollision/ContactAddedCallback.java +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btCollisionObjectData btCollisionObjectFloatData +public static final String btCollisionObjectDataName = "btCollisionObjectFloatData"; +// Targeting ../BulletCollision/btCollisionObject.java -public static native ContactAddedCallback gContactAddedCallback(); public static native void gContactAddedCallback(ContactAddedCallback setter); -// Targeting ../BulletCollision/CalculateCombinedCallback.java +// Targeting ../BulletCollision/btCollisionObjectDoubleData.java + +// Targeting ../BulletCollision/btCollisionObjectFloatData.java -public static native CalculateCombinedCallback gCalculateCombinedRestitutionCallback(); public static native void gCalculateCombinedRestitutionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedFrictionCallback(); public static native void gCalculateCombinedFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback(); public static native void gCalculateCombinedRollingFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback(); public static native void gCalculateCombinedSpinningFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedContactDampingCallback(); public static native void gCalculateCombinedContactDampingCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback(); public static native void gCalculateCombinedContactStiffnessCallback(CalculateCombinedCallback setter); -// Targeting ../BulletCollision/btManifoldResult.java +// clang-format on -// #endif //BT_MANIFOLD_RESULT_H +// #endif //BT_COLLISION_OBJECT_H -// Parsed from BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h +// Parsed from BulletCollision/CollisionDispatch/btCollisionWorld.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1915,22 +1868,81 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/** + * \mainpage Bullet Documentation + * + * \section intro_sec Introduction + * Bullet is a Collision Detection and Rigid Body Dynamics Library. The Library is Open Source and free for commercial use, under the ZLib license ( http://opensource.org/licenses/zlib-license.php ). + * + * The main documentation is Bullet_User_Manual.pdf, included in the source code distribution. + * There is the Physics Forum for feedback and general Collision Detection and Physics discussions. + * Please visit http://www.bulletphysics.org + * + * \section install_sec Installation + * + * \subsection step1 Step 1: Download + * You can download the Bullet Physics Library from the github repository: https://github.com/bulletphysics/bullet3/releases + * + * \subsection step2 Step 2: Building + * Bullet has multiple build systems, including premake, cmake and autotools. Premake and cmake support all platforms. + * Premake is included in the Bullet/build folder for Windows, Mac OSX and Linux. + * Under Windows you can click on Bullet/build/vs2010.bat to create Microsoft Visual Studio projects. + * On Mac OSX and Linux you can open a terminal and generate Makefile, codeblocks or Xcode4 projects: + * cd Bullet/build + * ./premake4_osx gmake or ./premake4_linux gmake or ./premake4_linux64 gmake or (for Mac) ./premake4_osx xcode4 + * cd Bullet/build/gmake + * make + * + * An alternative to premake is cmake. You can download cmake from http://www.cmake.org + * cmake can autogenerate projectfiles for Microsoft Visual Studio, Apple Xcode, KDevelop and Unix Makefiles. + * The easiest is to run the CMake cmake-gui graphical user interface and choose the options and generate projectfiles. + * You can also use cmake in the command-line. Here are some examples for various platforms: + * cmake . -G "Visual Studio 9 2008" + * cmake . -G Xcode + * cmake . -G "Unix Makefiles" + * Although cmake is recommended, you can also use autotools for UNIX: ./autogen.sh ./configure to create a Makefile and then run make. + * + * \subsection step3 Step 3: Testing demos + * Try to run and experiment with BasicDemo executable as a starting point. + * Bullet can be used in several ways, as Full Rigid Body simulation, as Collision Detector Library or Low Level / Snippets like the GJK Closest Point calculation. + * The Dependencies can be seen in this documentation under Directories + * + * \subsection step4 Step 4: Integrating in your application, full Rigid Body and Soft Body simulation + * Check out BasicDemo how to create a btDynamicsWorld, btRigidBody and btCollisionShape, Stepping the simulation and synchronizing your graphics object transform. + * Check out SoftDemo how to use soft body dynamics, using btSoftRigidDynamicsWorld. + * \subsection step5 Step 5 : Integrate the Collision Detection Library (without Dynamics and other Extras) + * Bullet Collision Detection can also be used without the Dynamics/Extras. + * Check out btCollisionWorld and btCollisionObject, and the CollisionInterfaceDemo. + * \subsection step6 Step 6 : Use Snippets like the GJK Closest Point calculation. + * Bullet has been designed in a modular way keeping dependencies to a minimum. The ConvexHullDistance demo demonstrates direct use of btGjkPairDetector. + * + * \section copyright Copyright + * For up-to-data information and copyright and contributors list check out the Bullet_User_Manual.pdf + * + */ + +// #ifndef BT_COLLISION_WORLD_H +// #define BT_COLLISION_WORLD_H -// #ifndef __BT_ACTIVATING_COLLISION_ALGORITHM_H -// #define __BT_ACTIVATING_COLLISION_ALGORITHM_H +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "btCollisionObject.h" +// #include "btCollisionDispatcher.h" +// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btCollisionWorld.java -// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" -// Targeting ../BulletCollision/btActivatingCollisionAlgorithm.java -// #endif //__BT_ACTIVATING_COLLISION_ALGORITHM_H +// #endif //BT_COLLISION_WORLD_H -// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h +// Parsed from BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -1947,18 +1959,22 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H -// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #ifndef BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H +// #define BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H -// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" // #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" // #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" -// #include "btCollisionDispatcher.h" -// Targeting ../BulletCollision/btSphereSphereCollisionAlgorithm.java +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +// #include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil +// Targeting ../BulletCollision/btConvex2dConvex2dAlgorithm.java -// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #endif //BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H // Parsed from BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h @@ -1992,7 +2008,7 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_DEFAULT_COLLISION_CONFIGURATION -// Parsed from BulletCollision/CollisionDispatch/btSimulationIslandManager.h +// Parsed from BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -2009,57 +2025,61 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SIMULATION_ISLAND_MANAGER_H -// #define BT_SIMULATION_ISLAND_MANAGER_H - -// #include "BulletCollision/CollisionDispatch/btUnionFind.h" +// #ifndef BT_EMPTY_ALGORITH +// #define BT_EMPTY_ALGORITH +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" // #include "btCollisionCreateFunc.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #include "btCollisionObject.h" -// Targeting ../BulletCollision/btSimulationIslandManager.java +// #include "btCollisionDispatcher.h" +// #define ATTRIBUTE_ALIGNED(a) +// Targeting ../BulletCollision/btEmptyAlgorithm.java -// #endif //BT_SIMULATION_ISLAND_MANAGER_H +// #endif //BT_EMPTY_ALGORITH -// Parsed from BulletCollision/CollisionDispatch/btUnionFind.h -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +// Parsed from BulletCollision/CollisionDispatch/btInternalEdgeUtility.h -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ +// #ifndef BT_INTERNAL_EDGE_UTILITY_H +// #define BT_INTERNAL_EDGE_UTILITY_H -// #ifndef BT_UNION_FIND_H -// #define BT_UNION_FIND_H +// #include "LinearMath/btHashMap.h" +// #include "LinearMath/btVector3.h" -// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" -public static final int USE_PATH_COMPRESSION = 1; +/**The btInternalEdgeUtility helps to avoid or reduce artifacts due to wrong collision normals caused by internal edges. + * See also http://code.google.com/p/bullet/issues/detail?id=27 */ -/**see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406 */ -public static final int STATIC_SIMULATION_ISLAND_OPTIMIZATION = 1; -// Targeting ../BulletCollision/btElement.java +/** enum btInternalEdgeAdjustFlags */ +public static final int + BT_TRIANGLE_CONVEX_BACKFACE_MODE = 1, + BT_TRIANGLE_CONCAVE_DOUBLE_SIDED = 2, //double sided options are experimental, single sided is recommended + BT_TRIANGLE_CONVEX_DOUBLE_SIDED = 4; +/**Call btGenerateInternalEdgeInfo to create triangle info, store in the shape 'userInfo' */ +public static native void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape trimeshShape, btTriangleInfoMap triangleInfoMap); -// Targeting ../BulletCollision/btUnionFind.java +public static native void btGenerateInternalEdgeInfo(btHeightfieldTerrainShape trimeshShape, btTriangleInfoMap triangleInfoMap); + +/**Call the btFixMeshNormal to adjust the collision normal, using the triangle info map (generated using btGenerateInternalEdgeInfo) + * If this info map is missing, or the triangle is not store in this map, nothing will be done */ +public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags/*=0*/); +public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0); +/**Enable the BT_INTERNAL_EDGE_DEBUG_DRAW define and call btSetDebugDrawer, to get visual info to see if the internal edge utility works properly. + * If the utility doesn't work properly, you might have to adjust the threshold values in btTriangleInfoMap */ +//#define BT_INTERNAL_EDGE_DEBUG_DRAW +// #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW +// #endif //BT_INTERNAL_EDGE_DEBUG_DRAW -// #endif //BT_UNION_FIND_H +// #endif //BT_INTERNAL_EDGE_UTILITY_H -// Parsed from BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h +// Parsed from BulletCollision/CollisionDispatch/btManifoldResult.h /* Bullet Continuous Collision Detection and Physics Library @@ -2076,19 +2096,38 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_COLLISION_DISPATCHER_MT_H -// #define BT_COLLISION_DISPATCHER_MT_H +// #ifndef BT_MANIFOLD_RESULT_H +// #define BT_MANIFOLD_RESULT_H -// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" -// #include "LinearMath/btThreads.h" -// Targeting ../BulletCollision/btCollisionDispatcherMt.java +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" +// #include "LinearMath/btTransform.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +// Targeting ../BulletCollision/ContactAddedCallback.java -// #endif //BT_COLLISION_DISPATCHER_MT_H +public static native ContactAddedCallback gContactAddedCallback(); public static native void gContactAddedCallback(ContactAddedCallback setter); +// Targeting ../BulletCollision/CalculateCombinedCallback.java -// Parsed from BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h + + +public static native CalculateCombinedCallback gCalculateCombinedRestitutionCallback(); public static native void gCalculateCombinedRestitutionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedFrictionCallback(); public static native void gCalculateCombinedFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback(); public static native void gCalculateCombinedRollingFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback(); public static native void gCalculateCombinedSpinningFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedContactDampingCallback(); public static native void gCalculateCombinedContactDampingCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback(); public static native void gCalculateCombinedContactStiffnessCallback(CalculateCombinedCallback setter); +// Targeting ../BulletCollision/btManifoldResult.java + + + +// #endif //BT_MANIFOLD_RESULT_H + + +// Parsed from BulletCollision/CollisionDispatch/btSimulationIslandManager.h /* Bullet Continuous Collision Detection and Physics Library @@ -2105,21 +2144,21 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H -// #define BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H +// #ifndef BT_SIMULATION_ISLAND_MANAGER_H +// #define BT_SIMULATION_ISLAND_MANAGER_H -// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" -// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" -// Targeting ../BulletCollision/btBox2dBox2dCollisionAlgorithm.java +// #include "BulletCollision/CollisionDispatch/btUnionFind.h" +// #include "btCollisionCreateFunc.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btCollisionObject.h" +// Targeting ../BulletCollision/btSimulationIslandManager.java -// #endif //BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H +// #endif //BT_SIMULATION_ISLAND_MANAGER_H -// Parsed from BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h +// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -2136,25 +2175,21 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H -// #define BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H +// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H -// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" -// #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" -// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "btActivatingCollisionAlgorithm.h" // #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" // #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" -// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" -// #include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil -// Targeting ../BulletCollision/btConvex2dConvex2dAlgorithm.java +// #include "btCollisionDispatcher.h" +// Targeting ../BulletCollision/btSphereSphereCollisionAlgorithm.java -// #endif //BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H +// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h +// Parsed from BulletCollision/CollisionDispatch/btUnionFind.h /* Bullet Continuous Collision Detection and Physics Library @@ -2171,65 +2206,30 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_EMPTY_ALGORITH -// #define BT_EMPTY_ALGORITH -// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" -// #include "btCollisionCreateFunc.h" -// #include "btCollisionDispatcher.h" - -// #define ATTRIBUTE_ALIGNED(a) -// Targeting ../BulletCollision/btEmptyAlgorithm.java - - - -// #endif //BT_EMPTY_ALGORITH - - -// Parsed from BulletCollision/CollisionDispatch/btInternalEdgeUtility.h - - -// #ifndef BT_INTERNAL_EDGE_UTILITY_H -// #define BT_INTERNAL_EDGE_UTILITY_H - -// #include "LinearMath/btHashMap.h" -// #include "LinearMath/btVector3.h" - -// #include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" - -/**The btInternalEdgeUtility helps to avoid or reduce artifacts due to wrong collision normals caused by internal edges. - * See also http://code.google.com/p/bullet/issues/detail?id=27 */ +// #ifndef BT_UNION_FIND_H +// #define BT_UNION_FIND_H -/** enum btInternalEdgeAdjustFlags */ -public static final int - BT_TRIANGLE_CONVEX_BACKFACE_MODE = 1, - BT_TRIANGLE_CONCAVE_DOUBLE_SIDED = 2, //double sided options are experimental, single sided is recommended - BT_TRIANGLE_CONVEX_DOUBLE_SIDED = 4; +// #include "LinearMath/btAlignedObjectArray.h" -/**Call btGenerateInternalEdgeInfo to create triangle info, store in the shape 'userInfo' */ -public static native void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape trimeshShape, btTriangleInfoMap triangleInfoMap); +public static final int USE_PATH_COMPRESSION = 1; -public static native void btGenerateInternalEdgeInfo(btHeightfieldTerrainShape trimeshShape, btTriangleInfoMap triangleInfoMap); +/**see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406 */ +public static final int STATIC_SIMULATION_ISLAND_OPTIMIZATION = 1; +// Targeting ../BulletCollision/btElement.java -/**Call the btFixMeshNormal to adjust the collision normal, using the triangle info map (generated using btGenerateInternalEdgeInfo) - * If this info map is missing, or the triangle is not store in this map, nothing will be done */ -public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags/*=0*/); -public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0); -/**Enable the BT_INTERNAL_EDGE_DEBUG_DRAW define and call btSetDebugDrawer, to get visual info to see if the internal edge utility works properly. - * If the utility doesn't work properly, you might have to adjust the threshold values in btTriangleInfoMap */ -//#define BT_INTERNAL_EDGE_DEBUG_DRAW +// Targeting ../BulletCollision/btUnionFind.java -// #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW -// #endif //BT_INTERNAL_EDGE_DEBUG_DRAW -// #endif //BT_INTERNAL_EDGE_UTILITY_H +// #endif //BT_UNION_FIND_H -// Parsed from BulletCollision/CollisionShapes/btCollisionShape.h + +// Parsed from BulletCollision/CollisionShapes/btBox2dShape.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2242,26 +2242,22 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_COLLISION_SHAPE_H -// #define BT_COLLISION_SHAPE_H +// #ifndef BT_OBB_BOX_2D_SHAPE_H +// #define BT_OBB_BOX_2D_SHAPE_H -// #include "LinearMath/btTransform.h" +// #include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" +// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // #include "LinearMath/btVector3.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types -// Targeting ../BulletCollision/btCollisionShape.java - - -// Targeting ../BulletCollision/btCollisionShapeData.java - +// #include "LinearMath/btMinMax.h" +// Targeting ../BulletCollision/btBox2dShape.java -// clang-format on -// #endif //BT_COLLISION_SHAPE_H +// #endif //BT_OBB_BOX_2D_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btConvexShape.h +// Parsed from BulletCollision/CollisionShapes/btBoxShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2278,30 +2274,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_SHAPE_INTERFACE1 -// #define BT_CONVEX_SHAPE_INTERFACE1 - -// #include "btCollisionShape.h" +// #ifndef BT_OBB_BOX_MINKOWSKI_H +// #define BT_OBB_BOX_MINKOWSKI_H -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btMatrix3x3.h" +// #include "btPolyhedralConvexShape.h" // #include "btCollisionMargin.h" -// #include "LinearMath/btAlignedAllocator.h" - -public static final int MAX_PREFERRED_PENETRATION_DIRECTIONS = 10; -// Targeting ../BulletCollision/btConvexShape.java +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMinMax.h" +// Targeting ../BulletCollision/btBoxShape.java -// #endif //BT_CONVEX_SHAPE_INTERFACE1 +// #endif //BT_OBB_BOX_MINKOWSKI_H -// Parsed from BulletCollision/CollisionShapes/btConvexPolyhedron.h +// Parsed from BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2314,26 +2306,28 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -/**This file was written by Erwin Coumans */ +// #ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H +// #define BT_BVH_TRIANGLE_MESH_SHAPE_H -// #ifndef _BT_POLYHEDRAL_FEATURES_H -// #define _BT_POLYHEDRAL_FEATURES_H +// #include "btTriangleMeshShape.h" +// #include "btOptimizedBvh.h" +// #include "LinearMath/btAlignedAllocator.h" +// #include "btTriangleInfoMap.h" +// Targeting ../BulletCollision/btBvhTriangleMeshShape.java -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btAlignedObjectArray.h" -public static final int TEST_INTERNAL_OBJECTS = 1; -// Targeting ../BulletCollision/btFace.java +// Targeting ../BulletCollision/btTriangleMeshShapeData.java -// Targeting ../BulletCollision/btConvexPolyhedron.java +// clang-format on -// #endif //_BT_POLYHEDRAL_FEATURES_H +// #endif //BT_BVH_TRIANGLE_MESH_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h + +// Parsed from BulletCollision/CollisionShapes/btCapsuleShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2350,22 +2344,35 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H -// #define BT_POLYHEDRAL_CONVEX_SHAPE_H +// #ifndef BT_CAPSULE_SHAPE_H +// #define BT_CAPSULE_SHAPE_H -// #include "LinearMath/btMatrix3x3.h" // #include "btConvexInternalShape.h" -// Targeting ../BulletCollision/btPolyhedralConvexShape.java +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btCapsuleShape.java -// Targeting ../BulletCollision/btPolyhedralConvexAabbCachingShape.java +// Targeting ../BulletCollision/btCapsuleShapeX.java +// Targeting ../BulletCollision/btCapsuleShapeZ.java -// #endif //BT_POLYHEDRAL_CONVEX_SHAPE_H +// Targeting ../BulletCollision/btCapsuleShapeData.java -// Parsed from BulletCollision/CollisionShapes/btConvexInternalShape.h + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + + + +// #endif //BT_CAPSULE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btCollisionShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2382,30 +2389,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_INTERNAL_SHAPE_H -// #define BT_CONVEX_INTERNAL_SHAPE_H - -// #include "btConvexShape.h" -// #include "LinearMath/btAabbUtil2.h" -// Targeting ../BulletCollision/btConvexInternalShape.java - - -// Targeting ../BulletCollision/btConvexInternalShapeData.java - - +// #ifndef BT_COLLISION_SHAPE_H +// #define BT_COLLISION_SHAPE_H +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types +// Targeting ../BulletCollision/btCollisionShape.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ +// Targeting ../BulletCollision/btCollisionShapeData.java -// Targeting ../BulletCollision/btConvexInternalAabbCachingShape.java +// clang-format on -// #endif //BT_CONVEX_INTERNAL_SHAPE_H +// #endif //BT_COLLISION_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btBoxShape.h +// Parsed from BulletCollision/CollisionShapes/btCompoundShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2422,22 +2425,39 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_OBB_BOX_MINKOWSKI_H -// #define BT_OBB_BOX_MINKOWSKI_H +// #ifndef BT_COMPOUND_SHAPE_H +// #define BT_COMPOUND_SHAPE_H + +// #include "btCollisionShape.h" -// #include "btPolyhedralConvexShape.h" -// #include "btCollisionMargin.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // #include "LinearMath/btVector3.h" -// #include "LinearMath/btMinMax.h" -// Targeting ../BulletCollision/btBoxShape.java +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btCompoundShapeChild.java -// #endif //BT_OBB_BOX_MINKOWSKI_H +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btCompoundShapeChild c1, @Const @ByRef btCompoundShapeChild c2); +// Targeting ../BulletCollision/btCompoundShape.java -// Parsed from BulletCollision/CollisionShapes/btSphereShape.h +// Targeting ../BulletCollision/btCompoundShapeChildData.java + + +// Targeting ../BulletCollision/btCompoundShapeData.java + + + +// clang-format on + + + +// #endif //BT_COMPOUND_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConcaveShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2453,19 +2473,32 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SPHERE_MINKOWSKI_H -// #define BT_SPHERE_MINKOWSKI_H -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btSphereShape.java +// #ifndef BT_CONCAVE_SHAPE_H +// #define BT_CONCAVE_SHAPE_H + +// #include "btCollisionShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "btTriangleCallback.h" + +/** PHY_ScalarType enumerates possible scalar types. + * See the btStridingMeshInterface or btHeightfieldTerrainShape for its use */ +/** enum PHY_ScalarType */ +public static final int + PHY_FLOAT = 0, + PHY_DOUBLE = 1, + PHY_INTEGER = 2, + PHY_SHORT = 3, + PHY_FIXEDPOINT88 = 4, + PHY_UCHAR = 5; +// Targeting ../BulletCollision/btConcaveShape.java -// #endif //BT_SPHERE_MINKOWSKI_H +// #endif //BT_CONCAVE_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btCapsuleShape.h +// Parsed from BulletCollision/CollisionShapes/btConeShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2482,21 +2515,21 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CAPSULE_SHAPE_H -// #define BT_CAPSULE_SHAPE_H +// #ifndef BT_CONE_MINKOWSKI_H +// #define BT_CONE_MINKOWSKI_H // #include "btConvexInternalShape.h" // #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btCapsuleShape.java +// Targeting ../BulletCollision/btConeShape.java -// Targeting ../BulletCollision/btCapsuleShapeX.java +// Targeting ../BulletCollision/btConeShapeX.java -// Targeting ../BulletCollision/btCapsuleShapeZ.java +// Targeting ../BulletCollision/btConeShapeZ.java -// Targeting ../BulletCollision/btCapsuleShapeData.java +// Targeting ../BulletCollision/btConeShapeData.java @@ -2505,12 +2538,10 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, /**fills the dataBuffer and returns the struct name (and 0 on failure) */ +// #endif //BT_CONE_MINKOWSKI_H -// #endif //BT_CAPSULE_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btCylinderShape.h +// Parsed from BulletCollision/CollisionShapes/btConvex2dShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2527,34 +2558,19 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CYLINDER_MINKOWSKI_H -// #define BT_CYLINDER_MINKOWSKI_H - -// #include "btBoxShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "LinearMath/btVector3.h" -// Targeting ../BulletCollision/btCylinderShape.java - - -// Targeting ../BulletCollision/btCylinderShapeX.java - - -// Targeting ../BulletCollision/btCylinderShapeZ.java - - -// Targeting ../BulletCollision/btCylinderShapeData.java - - - +// #ifndef BT_CONVEX_2D_SHAPE_H +// #define BT_CONVEX_2D_SHAPE_H +// #include "BulletCollision/CollisionShapes/btConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btConvex2dShape.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_CYLINDER_MINKOWSKI_H +// #endif //BT_CONVEX_2D_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btConeShape.h +// Parsed from BulletCollision/CollisionShapes/btConvexHullShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2571,33 +2587,27 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONE_MINKOWSKI_H -// #define BT_CONE_MINKOWSKI_H - -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btConeShape.java - - -// Targeting ../BulletCollision/btConeShapeX.java - - -// Targeting ../BulletCollision/btConeShapeZ.java +// #ifndef BT_CONVEX_HULL_SHAPE_H +// #define BT_CONVEX_HULL_SHAPE_H +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btConvexHullShape.java -// Targeting ../BulletCollision/btConeShapeData.java +// Targeting ../BulletCollision/btConvexHullShapeData.java +// clang-format on -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_CONE_MINKOWSKI_H +// #endif //BT_CONVEX_HULL_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btConcaveShape.h +// Parsed from BulletCollision/CollisionShapes/btConvexInternalShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2614,35 +2624,34 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONCAVE_SHAPE_H -// #define BT_CONCAVE_SHAPE_H +// #ifndef BT_CONVEX_INTERNAL_SHAPE_H +// #define BT_CONVEX_INTERNAL_SHAPE_H -// #include "btCollisionShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "btTriangleCallback.h" +// #include "btConvexShape.h" +// #include "LinearMath/btAabbUtil2.h" +// Targeting ../BulletCollision/btConvexInternalShape.java -/** PHY_ScalarType enumerates possible scalar types. - * See the btStridingMeshInterface or btHeightfieldTerrainShape for its use */ -/** enum PHY_ScalarType */ -public static final int - PHY_FLOAT = 0, - PHY_DOUBLE = 1, - PHY_INTEGER = 2, - PHY_SHORT = 3, - PHY_FIXEDPOINT88 = 4, - PHY_UCHAR = 5; -// Targeting ../BulletCollision/btConcaveShape.java + +// Targeting ../BulletCollision/btConvexInternalShapeData.java -// #endif //BT_CONCAVE_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btTriangleCallback.h +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + +// Targeting ../BulletCollision/btConvexInternalAabbCachingShape.java + + + +// #endif //BT_CONVEX_INTERNAL_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexPolyhedron.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2655,21 +2664,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TRIANGLE_CALLBACK_H -// #define BT_TRIANGLE_CALLBACK_H +/**This file was written by Erwin Coumans */ -// #include "LinearMath/btVector3.h" -// Targeting ../BulletCollision/btTriangleCallback.java +// #ifndef _BT_POLYHEDRAL_FEATURES_H +// #define _BT_POLYHEDRAL_FEATURES_H + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btAlignedObjectArray.h" +public static final int TEST_INTERNAL_OBJECTS = 1; +// Targeting ../BulletCollision/btFace.java -// Targeting ../BulletCollision/btInternalTriangleIndexCallback.java +// Targeting ../BulletCollision/btConvexPolyhedron.java -// #endif //BT_TRIANGLE_CALLBACK_H +// #endif //_BT_POLYHEDRAL_FEATURES_H -// Parsed from BulletCollision/CollisionShapes/btStaticPlaneShape.h + +// Parsed from BulletCollision/CollisionShapes/btConvexShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2686,26 +2700,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_STATIC_PLANE_SHAPE_H -// #define BT_STATIC_PLANE_SHAPE_H - -// #include "btConcaveShape.h" -// Targeting ../BulletCollision/btStaticPlaneShape.java - - -// Targeting ../BulletCollision/btStaticPlaneShapeData.java - +// #ifndef BT_CONVEX_SHAPE_INTERFACE1 +// #define BT_CONVEX_SHAPE_INTERFACE1 +// #include "btCollisionShape.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// #include "LinearMath/btAlignedAllocator.h" +public static final int MAX_PREFERRED_PENETRATION_DIRECTIONS = 10; +// Targeting ../BulletCollision/btConvexShape.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_STATIC_PLANE_SHAPE_H +// #endif //BT_CONVEX_SHAPE_INTERFACE1 -// Parsed from BulletCollision/CollisionShapes/btConvexHullShape.h +// Parsed from BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2721,28 +2735,19 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ - -// #ifndef BT_CONVEX_HULL_SHAPE_H -// #define BT_CONVEX_HULL_SHAPE_H +// #ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H +// #define BT_CONVEX_TRIANGLEMESH_SHAPE_H // #include "btPolyhedralConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btConvexHullShape.java - - -// Targeting ../BulletCollision/btConvexHullShapeData.java - - - -// clang-format on +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btConvexTriangleMeshShape.java -// #endif //BT_CONVEX_HULL_SHAPE_H +// #endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btStridingMeshInterface.h +// Parsed from BulletCollision/CollisionShapes/btCylinderShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2759,42 +2764,34 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_STRIDING_MESHINTERFACE_H -// #define BT_STRIDING_MESHINTERFACE_H +// #ifndef BT_CYLINDER_MINKOWSKI_H +// #define BT_CYLINDER_MINKOWSKI_H +// #include "btBoxShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types // #include "LinearMath/btVector3.h" -// #include "btTriangleCallback.h" -// #include "btConcaveShape.h" -// Targeting ../BulletCollision/btStridingMeshInterface.java - - -// Targeting ../BulletCollision/btIntIndexData.java - - -// Targeting ../BulletCollision/btShortIntIndexData.java - +// Targeting ../BulletCollision/btCylinderShape.java -// Targeting ../BulletCollision/btShortIntIndexTripletData.java +// Targeting ../BulletCollision/btCylinderShapeX.java -// Targeting ../BulletCollision/btCharIndexTripletData.java +// Targeting ../BulletCollision/btCylinderShapeZ.java -// Targeting ../BulletCollision/btMeshPartData.java +// Targeting ../BulletCollision/btCylinderShapeData.java -// Targeting ../BulletCollision/btStridingMeshInterfaceData.java -// clang-format on +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_STRIDING_MESHINTERFACE_H +// #endif //BT_CYLINDER_MINKOWSKI_H -// Parsed from BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h +// Parsed from BulletCollision/CollisionShapes/btEmptyShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2811,23 +2808,23 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H -// #define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H - -// #include "btStridingMeshInterface.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btScalar.h" -// Targeting ../BulletCollision/btIndexedMesh.java +// #ifndef BT_EMPTY_SHAPE_H +// #define BT_EMPTY_SHAPE_H +// #include "btConcaveShape.h" -// Targeting ../BulletCollision/btTriangleIndexVertexArray.java +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// Targeting ../BulletCollision/btEmptyShape.java -// #endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H +// #endif //BT_EMPTY_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btTriangleMesh.h +// Parsed from BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2844,20 +2841,19 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TRIANGLE_MESH_H -// #define BT_TRIANGLE_MESH_H +// #ifndef BT_HEIGHTFIELD_TERRAIN_SHAPE_H +// #define BT_HEIGHTFIELD_TERRAIN_SHAPE_H -// #include "btTriangleIndexVertexArray.h" -// #include "LinearMath/btVector3.h" +// #include "btConcaveShape.h" // #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btTriangleMesh.java +// Targeting ../BulletCollision/btHeightfieldTerrainShape.java -// #endif //BT_TRIANGLE_MESH_H +// #endif //BT_HEIGHTFIELD_TERRAIN_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h +// Parsed from BulletCollision/CollisionShapes/btMultiSphereShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2873,19 +2869,32 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H -// #define BT_CONVEX_TRIANGLEMESH_SHAPE_H -// #include "btPolyhedralConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btConvexTriangleMeshShape.java +// #ifndef BT_MULTI_SPHERE_MINKOWSKI_H +// #define BT_MULTI_SPHERE_MINKOWSKI_H + +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btAabbUtil2.h" +// Targeting ../BulletCollision/btMultiSphereShape.java + +// Targeting ../BulletCollision/btPositionAndRadius.java -// #endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H +// Targeting ../BulletCollision/btMultiSphereShapeData.java -// Parsed from BulletCollision/CollisionShapes/btTriangleMeshShape.h + +// clang-format on + + + +// #endif //BT_MULTI_SPHERE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btOptimizedBvh.h /* Bullet Continuous Collision Detection and Physics Library @@ -2902,19 +2911,20 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TRIANGLE_MESH_SHAPE_H -// #define BT_TRIANGLE_MESH_SHAPE_H +/**Contains contributions from Disney Studio's */ -// #include "btConcaveShape.h" -// #include "btStridingMeshInterface.h" -// Targeting ../BulletCollision/btTriangleMeshShape.java +// #ifndef BT_OPTIMIZED_BVH_H +// #define BT_OPTIMIZED_BVH_H +// #include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" +// Targeting ../BulletCollision/btOptimizedBvh.java -// #endif //BT_TRIANGLE_MESH_SHAPE_H +// #endif //BT_OPTIMIZED_BVH_H -// Parsed from BulletCollision/CollisionShapes/btOptimizedBvh.h + +// Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2931,24 +2941,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -/**Contains contributions from Disney Studio's */ +// #ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H +// #define BT_POLYHEDRAL_CONVEX_SHAPE_H -// #ifndef BT_OPTIMIZED_BVH_H -// #define BT_OPTIMIZED_BVH_H +// #include "LinearMath/btMatrix3x3.h" +// #include "btConvexInternalShape.h" +// Targeting ../BulletCollision/btPolyhedralConvexShape.java -// #include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" -// Targeting ../BulletCollision/btOptimizedBvh.java +// Targeting ../BulletCollision/btPolyhedralConvexAabbCachingShape.java -// #endif //BT_OPTIMIZED_BVH_H +// #endif //BT_POLYHEDRAL_CONVEX_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btTriangleInfoMap.h + +// Parsed from BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2010 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2961,47 +2973,39 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef _BT_TRIANGLE_INFO_MAP_H -// #define _BT_TRIANGLE_INFO_MAP_H - -// #include "LinearMath/btHashMap.h" -// #include "LinearMath/btSerializer.h" - -/**for btTriangleInfo m_flags */ -public static final int TRI_INFO_V0V1_CONVEX = 1; -public static final int TRI_INFO_V1V2_CONVEX = 2; -public static final int TRI_INFO_V2V0_CONVEX = 4; +// #ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +// #define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H -public static final int TRI_INFO_V0V1_SWAP_NORMALB = 8; -public static final int TRI_INFO_V1V2_SWAP_NORMALB = 16; -public static final int TRI_INFO_V2V0_SWAP_NORMALB = 32; -// Targeting ../BulletCollision/btTriangleInfo.java +// #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" +// Targeting ../BulletCollision/btScaledBvhTriangleMeshShape.java -// Targeting ../BulletCollision/btTriangleInfoMap.java +// Targeting ../BulletCollision/btScaledTriangleMeshShapeData.java -// Targeting ../BulletCollision/btTriangleInfoData.java -// Targeting ../BulletCollision/btTriangleInfoMapData.java +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// clang-format on +// #endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +// Parsed from BulletCollision/CollisionShapes/btSdfCollisionShape.h -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ +// #ifndef BT_SDF_COLLISION_SHAPE_H +// #define BT_SDF_COLLISION_SHAPE_H +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btSdfCollisionShape.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //_BT_TRIANGLE_INFO_MAP_H +// #endif //BT_SDF_COLLISION_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h +// Parsed from BulletCollision/CollisionShapes/btShapeHull.h /* Bullet Continuous Collision Detection and Physics Library @@ -3018,28 +3022,49 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H -// #define BT_BVH_TRIANGLE_MESH_SHAPE_H +/**btShapeHull implemented by John McCutchan. */ -// #include "btTriangleMeshShape.h" -// #include "btOptimizedBvh.h" -// #include "LinearMath/btAlignedAllocator.h" -// #include "btTriangleInfoMap.h" -// Targeting ../BulletCollision/btBvhTriangleMeshShape.java +// #ifndef BT_SHAPE_HULL_H +// #define BT_SHAPE_HULL_H +// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletCollision/CollisionShapes/btConvexShape.h" +// Targeting ../BulletCollision/btShapeHull.java -// Targeting ../BulletCollision/btTriangleMeshShapeData.java +// #endif //BT_SHAPE_HULL_H -// clang-format on +// Parsed from BulletCollision/CollisionShapes/btSphereShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_SPHERE_MINKOWSKI_H +// #define BT_SPHERE_MINKOWSKI_H -// #endif //BT_BVH_TRIANGLE_MESH_SHAPE_H +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btSphereShape.java -// Parsed from BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h + +// #endif //BT_SPHERE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btStaticPlaneShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3056,14 +3081,14 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H -// #define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +// #ifndef BT_STATIC_PLANE_SHAPE_H +// #define BT_STATIC_PLANE_SHAPE_H -// #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" -// Targeting ../BulletCollision/btScaledBvhTriangleMeshShape.java +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btStaticPlaneShape.java -// Targeting ../BulletCollision/btScaledTriangleMeshShapeData.java +// Targeting ../BulletCollision/btStaticPlaneShapeData.java @@ -3072,10 +3097,10 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, /**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +// #endif //BT_STATIC_PLANE_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btCompoundShape.h +// Parsed from BulletCollision/CollisionShapes/btStridingMeshInterface.h /* Bullet Continuous Collision Detection and Physics Library @@ -3092,28 +3117,31 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_COMPOUND_SHAPE_H -// #define BT_COMPOUND_SHAPE_H - -// #include "btCollisionShape.h" +// #ifndef BT_STRIDING_MESHINTERFACE_H +// #define BT_STRIDING_MESHINTERFACE_H // #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "btCollisionMargin.h" -// #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btCompoundShapeChild.java +// #include "btTriangleCallback.h" +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btStridingMeshInterface.java +// Targeting ../BulletCollision/btIntIndexData.java -public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btCompoundShapeChild c1, @Const @ByRef btCompoundShapeChild c2); -// Targeting ../BulletCollision/btCompoundShape.java +// Targeting ../BulletCollision/btShortIntIndexData.java -// Targeting ../BulletCollision/btCompoundShapeChildData.java +// Targeting ../BulletCollision/btShortIntIndexTripletData.java -// Targeting ../BulletCollision/btCompoundShapeData.java + +// Targeting ../BulletCollision/btCharIndexTripletData.java + + +// Targeting ../BulletCollision/btMeshPartData.java + + +// Targeting ../BulletCollision/btStridingMeshInterfaceData.java @@ -3121,7 +3149,7 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, -// #endif //BT_COMPOUND_SHAPE_H +// #endif //BT_STRIDING_MESHINTERFACE_H // Parsed from BulletCollision/CollisionShapes/btTetrahedronShape.h @@ -3153,7 +3181,7 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_SIMPLEX_1TO4_SHAPE -// Parsed from BulletCollision/CollisionShapes/btEmptyShape.h +// Parsed from BulletCollision/CollisionShapes/btTriangleCallback.h /* Bullet Continuous Collision Detection and Physics Library @@ -3170,23 +3198,21 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_EMPTY_SHAPE_H -// #define BT_EMPTY_SHAPE_H - -// #include "btConcaveShape.h" +// #ifndef BT_TRIANGLE_CALLBACK_H +// #define BT_TRIANGLE_CALLBACK_H // #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "btCollisionMargin.h" -// Targeting ../BulletCollision/btEmptyShape.java +// Targeting ../BulletCollision/btTriangleCallback.java + +// Targeting ../BulletCollision/btInternalTriangleIndexCallback.java -// #endif //BT_EMPTY_SHAPE_H +// #endif //BT_TRIANGLE_CALLBACK_H -// Parsed from BulletCollision/CollisionShapes/btMultiSphereShape.h + +// Parsed from BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h /* Bullet Continuous Collision Detection and Physics Library @@ -3203,35 +3229,27 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_MULTI_SPHERE_MINKOWSKI_H -// #define BT_MULTI_SPHERE_MINKOWSKI_H +// #ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H +// #define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "btStridingMeshInterface.h" // #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btAabbUtil2.h" -// Targeting ../BulletCollision/btMultiSphereShape.java - - -// Targeting ../BulletCollision/btPositionAndRadius.java - - -// Targeting ../BulletCollision/btMultiSphereShapeData.java - +// #include "LinearMath/btScalar.h" +// Targeting ../BulletCollision/btIndexedMesh.java -// clang-format on +// Targeting ../BulletCollision/btTriangleIndexVertexArray.java -// #endif //BT_MULTI_SPHERE_MINKOWSKI_H +// #endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H -// Parsed from BulletCollision/CollisionShapes/btUniformScalingShape.h +// Parsed from BulletCollision/CollisionShapes/btTriangleInfoMap.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2010 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -3244,51 +3262,47 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_UNIFORM_SCALING_SHAPE_H -// #define BT_UNIFORM_SCALING_SHAPE_H +// #ifndef _BT_TRIANGLE_INFO_MAP_H +// #define _BT_TRIANGLE_INFO_MAP_H -// #include "btConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btUniformScalingShape.java +// #include "LinearMath/btHashMap.h" +// #include "LinearMath/btSerializer.h" +/**for btTriangleInfo m_flags */ +public static final int TRI_INFO_V0V1_CONVEX = 1; +public static final int TRI_INFO_V1V2_CONVEX = 2; +public static final int TRI_INFO_V2V0_CONVEX = 4; +public static final int TRI_INFO_V0V1_SWAP_NORMALB = 8; +public static final int TRI_INFO_V1V2_SWAP_NORMALB = 16; +public static final int TRI_INFO_V2V0_SWAP_NORMALB = 32; +// Targeting ../BulletCollision/btTriangleInfo.java -// #endif //BT_UNIFORM_SCALING_SHAPE_H +// Targeting ../BulletCollision/btTriangleInfoMap.java -// Parsed from BulletCollision/CollisionShapes/btBox2dShape.h -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +// Targeting ../BulletCollision/btTriangleInfoData.java -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ +// Targeting ../BulletCollision/btTriangleInfoMapData.java -// #ifndef BT_OBB_BOX_2D_SHAPE_H -// #define BT_OBB_BOX_2D_SHAPE_H -// #include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" -// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btMinMax.h" -// Targeting ../BulletCollision/btBox2dShape.java +// clang-format on -// #endif //BT_OBB_BOX_2D_SHAPE_H +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //_BT_TRIANGLE_INFO_MAP_H -// Parsed from BulletCollision/CollisionShapes/btConvex2dShape.h + +// Parsed from BulletCollision/CollisionShapes/btTriangleMesh.h /* Bullet Continuous Collision Detection and Physics Library @@ -3305,19 +3319,20 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_2D_SHAPE_H -// #define BT_CONVEX_2D_SHAPE_H +// #ifndef BT_TRIANGLE_MESH_H +// #define BT_TRIANGLE_MESH_H -// #include "BulletCollision/CollisionShapes/btConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btConvex2dShape.java +// #include "btTriangleIndexVertexArray.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btTriangleMesh.java -// #endif //BT_CONVEX_2D_SHAPE_H +// #endif //BT_TRIANGLE_MESH_H -// Parsed from BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h +// Parsed from BulletCollision/CollisionShapes/btTriangleMeshShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3334,16 +3349,16 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_HEIGHTFIELD_TERRAIN_SHAPE_H -// #define BT_HEIGHTFIELD_TERRAIN_SHAPE_H +// #ifndef BT_TRIANGLE_MESH_SHAPE_H +// #define BT_TRIANGLE_MESH_SHAPE_H // #include "btConcaveShape.h" -// #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btHeightfieldTerrainShape.java +// #include "btStridingMeshInterface.h" +// Targeting ../BulletCollision/btTriangleMeshShape.java -// #endif //BT_HEIGHTFIELD_TERRAIN_SHAPE_H +// #endif //BT_TRIANGLE_MESH_SHAPE_H // Parsed from BulletCollision/CollisionShapes/btTriangleShape.h @@ -3375,20 +3390,7 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_OBB_TRIANGLE_MINKOWSKI_H -// Parsed from BulletCollision/CollisionShapes/btSdfCollisionShape.h - -// #ifndef BT_SDF_COLLISION_SHAPE_H -// #define BT_SDF_COLLISION_SHAPE_H - -// #include "btConcaveShape.h" -// Targeting ../BulletCollision/btSdfCollisionShape.java - - - -// #endif //BT_SDF_COLLISION_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btShapeHull.h +// Parsed from BulletCollision/CollisionShapes/btUniformScalingShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3405,18 +3407,16 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -/**btShapeHull implemented by John McCutchan. */ - -// #ifndef BT_SHAPE_HULL_H -// #define BT_SHAPE_HULL_H +// #ifndef BT_UNIFORM_SCALING_SHAPE_H +// #define BT_UNIFORM_SCALING_SHAPE_H -// #include "LinearMath/btAlignedObjectArray.h" -// #include "BulletCollision/CollisionShapes/btConvexShape.h" -// Targeting ../BulletCollision/btShapeHull.java +// #include "btConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btUniformScalingShape.java -// #endif //BT_SHAPE_HULL_H +// #endif //BT_UNIFORM_SCALING_SHAPE_H // Parsed from BulletCollision/Gimpact/btGImpactShape.h diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index d34f4e23e94..35078b36f57 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -67,7 +67,7 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #endif //BT_OBJECT_ARRAY__ -// Parsed from BulletDynamics/Dynamics/btActionInterface.h +// Parsed from BulletDynamics/ConstraintSolver/btBatchedConstraints.h /* Bullet Continuous Collision Detection and Physics Library @@ -84,23 +84,25 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef _BT_ACTION_INTERFACE_H -// #define _BT_ACTION_INTERFACE_H +// #ifndef BT_BATCHED_CONSTRAINTS_H +// #define BT_BATCHED_CONSTRAINTS_H -// #include "LinearMath/btScalar.h" -// #include "btRigidBody.h" -// Targeting ../BulletDynamics/btActionInterface.java +// #include "LinearMath/btThreads.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" +// #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" +// Targeting ../BulletDynamics/btBatchedConstraints.java -// #endif //_BT_ACTION_INTERFACE_H +// #endif // BT_BATCHED_CONSTRAINTS_H -// Parsed from BulletDynamics/Dynamics/btRigidBody.h +// Parsed from BulletDynamics/ConstraintSolver/btConeTwistConstraint.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -111,49 +113,63 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. + +Written by: Marcus Hennix */ -// #ifndef BT_RIGIDBODY_H -// #define BT_RIGIDBODY_H +/* +Overview: -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btTransform.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc). +It is a fixed translation, 3 degree-of-freedom (DOF) rotational "joint". +It divides the 3 rotational DOFs into swing (movement within a cone) and twist. +Swing is divided into swing1 and swing2 which can have different limits, giving an elliptical shape. +(Note: the cone's base isn't flat, so this ellipse is "embedded" on the surface of a sphere.) -public static native @Cast("btScalar") float gDeactivationTime(); public static native void gDeactivationTime(float setter); -public static native @Cast("bool") boolean gDisableDeactivation(); public static native void gDisableDeactivation(boolean setter); +In the contraint's frame of reference: +twist is along the x-axis, +and swing 1 and 2 are along the z and y axes respectively. +*/ + +// #ifndef BT_CONETWISTCONSTRAINT_H +// #define BT_CONETWISTCONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" // #ifdef BT_USE_DOUBLE_PRECISION // #else -// #define btRigidBodyData btRigidBodyFloatData -public static final String btRigidBodyDataName = "btRigidBodyFloatData"; +// #define btConeTwistConstraintData2 btConeTwistConstraintData +public static final String btConeTwistConstraintDataName = "btConeTwistConstraintData"; // #endif //BT_USE_DOUBLE_PRECISION -/** enum btRigidBodyFlags */ +/** enum btConeTwistFlags */ public static final int - BT_DISABLE_WORLD_GRAVITY = 1, - /**BT_ENABLE_GYROPSCOPIC_FORCE flags is enabled by default in Bullet 2.83 and onwards. - * and it BT_ENABLE_GYROPSCOPIC_FORCE becomes equivalent to BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY - * See Demos/GyroscopicDemo and computeGyroscopicImpulseImplicit */ - BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT = 2, - BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD = 4, - BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY = 8, - BT_ENABLE_GYROPSCOPIC_FORCE = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY; -// Targeting ../BulletDynamics/btRigidBody.java + BT_CONETWIST_FLAGS_LIN_CFM = 1, + BT_CONETWIST_FLAGS_LIN_ERP = 2, + BT_CONETWIST_FLAGS_ANG_CFM = 4; +// Targeting ../BulletDynamics/btConeTwistConstraint.java -// Targeting ../BulletDynamics/btRigidBodyFloatData.java +// Targeting ../BulletDynamics/btConeTwistConstraintDoubleData.java -// Targeting ../BulletDynamics/btRigidBodyDoubleData.java +// Targeting ../BulletDynamics/btConeTwistConstraintData.java + +// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION +// -// #endif //BT_RIGIDBODY_H + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// Parsed from BulletDynamics/Dynamics/btDynamicsWorld.h +// #endif //BT_CONETWISTCONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btConstraintSolver.h /* Bullet Continuous Collision Detection and Physics Library @@ -170,35 +186,24 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_DYNAMICS_WORLD_H -// #define BT_DYNAMICS_WORLD_H - -// #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" -// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" -// Targeting ../BulletDynamics/btInternalTickCallback.java - +// #ifndef BT_CONSTRAINT_SOLVER_H +// #define BT_CONSTRAINT_SOLVER_H +// #include "LinearMath/btScalar.h" +/** btConstraintSolver provides solver interface */ -/** enum btDynamicsWorldType */ +/** enum btConstraintSolverType */ public static final int - BT_SIMPLE_DYNAMICS_WORLD = 1, - BT_DISCRETE_DYNAMICS_WORLD = 2, - BT_CONTINUOUS_DYNAMICS_WORLD = 3, - BT_SOFT_RIGID_DYNAMICS_WORLD = 4, - BT_GPU_DYNAMICS_WORLD = 5, - BT_SOFT_MULTIBODY_DYNAMICS_WORLD = 6, - BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD = 7; -// Targeting ../BulletDynamics/btDynamicsWorld.java - - -// Targeting ../BulletDynamics/btDynamicsWorldDoubleData.java - - -// Targeting ../BulletDynamics/btDynamicsWorldFloatData.java + BT_SEQUENTIAL_IMPULSE_SOLVER = 1, + BT_MLCP_SOLVER = 2, + BT_NNCG_SOLVER = 4, + BT_MULTIBODY_SOLVER = 8, + BT_BLOCK_SOLVER = 16; +// Targeting ../BulletDynamics/btConstraintSolver.java -// #endif //BT_DYNAMICS_WORLD_H +// #endif //BT_CONSTRAINT_SOLVER_H // Parsed from BulletDynamics/ConstraintSolver/btContactSolverInfo.h @@ -253,11 +258,11 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #endif //BT_CONTACT_SOLVER_INFO -// Parsed from BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h +// Parsed from BulletDynamics/ConstraintSolver/btFixedConstraint.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -270,25 +275,22 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_DISCRETE_DYNAMICS_WORLD_H -// #define BT_DISCRETE_DYNAMICS_WORLD_H - -// #include "btDynamicsWorld.h" +// #ifndef BT_FIXED_CONSTRAINT_H +// #define BT_FIXED_CONSTRAINT_H -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btThreads.h" -// Targeting ../BulletDynamics/btDiscreteDynamicsWorld.java +// #include "btGeneric6DofSpring2Constraint.h" +// Targeting ../BulletDynamics/btFixedConstraint.java -// #endif //BT_DISCRETE_DYNAMICS_WORLD_H +// #endif //BT_FIXED_CONSTRAINT_H -// Parsed from BulletDynamics/Dynamics/btSimpleDynamicsWorld.h +// Parsed from BulletDynamics/ConstraintSolver/btGearConstraint.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +Copyright (c) 2012 Advanced Micro Devices, Inc. http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -301,18 +303,34 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SIMPLE_DYNAMICS_WORLD_H -// #define BT_SIMPLE_DYNAMICS_WORLD_H +// #ifndef BT_GEAR_CONSTRAINT_H +// #define BT_GEAR_CONSTRAINT_H -// #include "btDynamicsWorld.h" -// Targeting ../BulletDynamics/btSimpleDynamicsWorld.java +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGearConstraintData btGearConstraintFloatData +public static final String btGearConstraintDataName = "btGearConstraintFloatData"; +// Targeting ../BulletDynamics/btGearConstraint.java -// #endif //BT_SIMPLE_DYNAMICS_WORLD_H +// Targeting ../BulletDynamics/btGearConstraintFloatData.java -// Parsed from BulletDynamics/ConstraintSolver/btConstraintSolver.h +// Targeting ../BulletDynamics/btGearConstraintDoubleData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_GEAR_CONSTRAINT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h /* Bullet Continuous Collision Detection and Physics Library @@ -320,8 +338,8 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -329,65 +347,59 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONSTRAINT_SOLVER_H -// #define BT_CONSTRAINT_SOLVER_H +/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ -// #include "LinearMath/btScalar.h" -/** btConstraintSolver provides solver interface */ +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ -/** enum btConstraintSolverType */ -public static final int - BT_SEQUENTIAL_IMPULSE_SOLVER = 1, - BT_MLCP_SOLVER = 2, - BT_NNCG_SOLVER = 4, - BT_MULTIBODY_SOLVER = 8, - BT_BLOCK_SOLVER = 16; -// Targeting ../BulletDynamics/btConstraintSolver.java +// #ifndef BT_GENERIC_6DOF_CONSTRAINT_H +// #define BT_GENERIC_6DOF_CONSTRAINT_H +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGeneric6DofConstraintData2 btGeneric6DofConstraintData +public static final String btGeneric6DofConstraintDataName = "btGeneric6DofConstraintData"; +// Targeting ../BulletDynamics/btRotationalLimitMotor.java -// #endif //BT_CONSTRAINT_SOLVER_H +// Targeting ../BulletDynamics/btTranslationalLimitMotor.java -// Parsed from BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: +/** enum bt6DofFlags */ +public static final int + BT_6DOF_FLAGS_CFM_NORM = 1, + BT_6DOF_FLAGS_CFM_STOP = 2, + BT_6DOF_FLAGS_ERP_STOP = 4; +public static final int BT_6DOF_FLAGS_AXIS_SHIFT = 3; +// Targeting ../BulletDynamics/btGeneric6DofConstraint.java -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ -// #ifndef BT_DISCRETE_DYNAMICS_WORLD_MT_H -// #define BT_DISCRETE_DYNAMICS_WORLD_MT_H +// Targeting ../BulletDynamics/btGeneric6DofConstraintData.java -// #include "btDiscreteDynamicsWorld.h" -// #include "btSimulationIslandManagerMt.h" +// Targeting ../BulletDynamics/btGeneric6DofConstraintDoubleData2.java -/// -/// -/// -// #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" -// Targeting ../BulletDynamics/btConstraintSolverPoolMt.java -// Targeting ../BulletDynamics/btDiscreteDynamicsWorldMt.java +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_DISCRETE_DYNAMICS_WORLD_H +// #endif //BT_GENERIC_6DOF_CONSTRAINT_H -// Parsed from BulletDynamics/Dynamics/btSimulationIslandManagerMt.h + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h /* Bullet Continuous Collision Detection and Physics Library @@ -395,8 +407,8 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -404,22 +416,88 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SIMULATION_ISLAND_MANAGER_MT_H -// #define BT_SIMULATION_ISLAND_MANAGER_MT_H +/* +2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer +Pros: +- Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled) +- Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring) +- Servo motor functionality +- Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision) +- Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2) -// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" -// Targeting ../BulletDynamics/btSimulationIslandManagerMt.java +Cons: +- It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation. +- At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.) +*/ +/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev +/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ + +/* +2007-09-09 +btGeneric6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ +// #ifndef BT_GENERIC_6DOF_CONSTRAINT2_H +// #define BT_GENERIC_6DOF_CONSTRAINT2_H -// #endif //BT_SIMULATION_ISLAND_MANAGER_H +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData +public static final String btGeneric6DofSpring2ConstraintDataName = "btGeneric6DofSpring2ConstraintData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum RotateOrder */ +public static final int + RO_XYZ = 0, + RO_XZY = 1, + RO_YXZ = 2, + RO_YZX = 3, + RO_ZXY = 4, + RO_ZYX = 5; +// Targeting ../BulletDynamics/btRotationalLimitMotor2.java + + +// Targeting ../BulletDynamics/btTranslationalLimitMotor2.java + + + +/** enum bt6DofFlags2 */ +public static final int + BT_6DOF_FLAGS_CFM_STOP2 = 1, + BT_6DOF_FLAGS_ERP_STOP2 = 2, + BT_6DOF_FLAGS_CFM_MOTO2 = 4, + BT_6DOF_FLAGS_ERP_MOTO2 = 8, + BT_6DOF_FLAGS_USE_INFINITE_ERROR = (1<<16); +public static final int BT_6DOF_FLAGS_AXIS_SHIFT2 = 4; +// Targeting ../BulletDynamics/btGeneric6DofSpring2Constraint.java + + +// Targeting ../BulletDynamics/btGeneric6DofSpring2ConstraintData.java + + +// Targeting ../BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java + + + + + + + +// #endif //BT_GENERIC_6DOF_CONSTRAINT_H -// Parsed from BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h + +// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h /* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -432,45 +510,63 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_POINT2POINTCONSTRAINT_H -// #define BT_POINT2POINTCONSTRAINT_H +// #ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H +// #define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H // #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" // #include "btTypedConstraint.h" +// #include "btGeneric6DofConstraint.h" // #ifdef BT_USE_DOUBLE_PRECISION // #else -// #define btPoint2PointConstraintData2 btPoint2PointConstraintFloatData -public static final String btPoint2PointConstraintDataName = "btPoint2PointConstraintFloatData"; -// Targeting ../BulletDynamics/btConstraintSetting.java +// #define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData +public static final String btGeneric6DofSpringConstraintDataName = "btGeneric6DofSpringConstraintData"; +// Targeting ../BulletDynamics/btGeneric6DofSpringConstraint.java +// Targeting ../BulletDynamics/btGeneric6DofSpringConstraintData.java -/** enum btPoint2PointFlags */ -public static final int - BT_P2P_FLAGS_ERP = 1, - BT_P2P_FLAGS_CFM = 2; -// Targeting ../BulletDynamics/btPoint2PointConstraint.java +// Targeting ../BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java -// Targeting ../BulletDynamics/btPoint2PointConstraintFloatData.java -// Targeting ../BulletDynamics/btPoint2PointConstraintDoubleData2.java -// Targeting ../BulletDynamics/btPoint2PointConstraintDoubleData.java +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION +// #endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H + +// Parsed from BulletDynamics/ConstraintSolver/btHinge2Constraint.h +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_HINGE2_CONSTRAINT_H +// #define BT_HINGE2_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btTypedConstraint.h" +// #include "btGeneric6DofSpring2Constraint.h" +// Targeting ../BulletDynamics/btHinge2Constraint.java -// #endif //BT_POINT2POINTCONSTRAINT_H + +// #endif // BT_HINGE2_CONSTRAINT_H // Parsed from BulletDynamics/ConstraintSolver/btHingeConstraint.h @@ -537,11 +633,11 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #endif //BT_HINGECONSTRAINT_H -// Parsed from BulletDynamics/ConstraintSolver/btConeTwistConstraint.h +// Parsed from BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h /* Bullet Continuous Collision Detection and Physics Library -btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -552,26 +648,38 @@ btConeTwistConstraint is Copyright (c) 2007 Starbreeze Studios 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. - -Written by: Marcus Hennix */ +// #ifndef BT_NNCG_CONSTRAINT_SOLVER_H +// #define BT_NNCG_CONSTRAINT_SOLVER_H + +// #include "btSequentialImpulseConstraintSolver.h" +// Targeting ../BulletDynamics/btNNCGConstraintSolver.java + + + +// #endif //BT_NNCG_CONSTRAINT_SOLVER_H + + +// Parsed from BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h + /* -Overview: +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org -btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc). -It is a fixed translation, 3 degree-of-freedom (DOF) rotational "joint". -It divides the 3 rotational DOFs into swing (movement within a cone) and twist. -Swing is divided into swing1 and swing2 which can have different limits, giving an elliptical shape. -(Note: the cone's base isn't flat, so this ellipse is "embedded" on the surface of a sphere.) +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: -In the contraint's frame of reference: -twist is along the x-axis, -and swing 1 and 2 are along the z and y axes respectively. +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONETWISTCONSTRAINT_H -// #define BT_CONETWISTCONSTRAINT_H +// #ifndef BT_POINT2POINTCONSTRAINT_H +// #define BT_POINT2POINTCONSTRAINT_H // #include "LinearMath/btVector3.h" // #include "btJacobianEntry.h" @@ -579,36 +687,39 @@ btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc // #ifdef BT_USE_DOUBLE_PRECISION // #else -// #define btConeTwistConstraintData2 btConeTwistConstraintData -public static final String btConeTwistConstraintDataName = "btConeTwistConstraintData"; -// #endif //BT_USE_DOUBLE_PRECISION +// #define btPoint2PointConstraintData2 btPoint2PointConstraintFloatData +public static final String btPoint2PointConstraintDataName = "btPoint2PointConstraintFloatData"; +// Targeting ../BulletDynamics/btConstraintSetting.java -/** enum btConeTwistFlags */ + + +/** enum btPoint2PointFlags */ public static final int - BT_CONETWIST_FLAGS_LIN_CFM = 1, - BT_CONETWIST_FLAGS_LIN_ERP = 2, - BT_CONETWIST_FLAGS_ANG_CFM = 4; -// Targeting ../BulletDynamics/btConeTwistConstraint.java + BT_P2P_FLAGS_ERP = 1, + BT_P2P_FLAGS_CFM = 2; +// Targeting ../BulletDynamics/btPoint2PointConstraint.java -// Targeting ../BulletDynamics/btConeTwistConstraintDoubleData.java +// Targeting ../BulletDynamics/btPoint2PointConstraintFloatData.java -// Targeting ../BulletDynamics/btConeTwistConstraintData.java +// Targeting ../BulletDynamics/btPoint2PointConstraintDoubleData2.java + + +// Targeting ../BulletDynamics/btPoint2PointConstraintDoubleData.java // #endif //BT_BACKWARDS_COMPATIBLE_SERIALIZATION -// /**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_CONETWISTCONSTRAINT_H +// #endif //BT_POINT2POINTCONSTRAINT_H -// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h +// Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h /* Bullet Continuous Collision Detection and Physics Library @@ -625,59 +736,25 @@ btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc 3. This notice may not be removed or altered from any source distribution. */ -/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev -/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ - -/* -2007-09-09 -btGeneric6DofConstraint Refactored by Francisco Le?n -email: projectileman@yahoo.com -http://gimpact.sf.net -*/ - -// #ifndef BT_GENERIC_6DOF_CONSTRAINT_H -// #define BT_GENERIC_6DOF_CONSTRAINT_H - -// #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" -// #include "btTypedConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btGeneric6DofConstraintData2 btGeneric6DofConstraintData -public static final String btGeneric6DofConstraintDataName = "btGeneric6DofConstraintData"; -// Targeting ../BulletDynamics/btRotationalLimitMotor.java - - -// Targeting ../BulletDynamics/btTranslationalLimitMotor.java - - - -/** enum bt6DofFlags */ -public static final int - BT_6DOF_FLAGS_CFM_NORM = 1, - BT_6DOF_FLAGS_CFM_STOP = 2, - BT_6DOF_FLAGS_ERP_STOP = 4; -public static final int BT_6DOF_FLAGS_AXIS_SHIFT = 3; -// Targeting ../BulletDynamics/btGeneric6DofConstraint.java - - -// Targeting ../BulletDynamics/btGeneric6DofConstraintData.java - - -// Targeting ../BulletDynamics/btGeneric6DofConstraintDoubleData2.java - - +// #ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H +// #define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +// #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" +// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" +// #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" +// #include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" +// #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" +// Targeting ../BulletDynamics/btSolverAnalyticsData.java +// Targeting ../BulletDynamics/btSequentialImpulseConstraintSolver.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_GENERIC_6DOF_CONSTRAINT_H +// #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H -// Parsed from BulletDynamics/ConstraintSolver/btSliderConstraint.h +// Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h /* Bullet Continuous Collision Detection and Physics Library @@ -694,9 +771,48 @@ btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc 3. This notice may not be removed or altered from any source distribution. */ -/* -Added by Roman Ponomarev (rponom@gmail.com) -April 04, 2008 +// #ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H +// #define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H + +// #include "btSequentialImpulseConstraintSolver.h" +// #include "btBatchedConstraints.h" + + +/// +/// +/// +/// +/// +/// +/// +// #include "LinearMath/btThreads.h" +// Targeting ../BulletDynamics/btSequentialImpulseConstraintSolverMt.java + + + +// #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H + + +// Parsed from BulletDynamics/ConstraintSolver/btSliderConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +Added by Roman Ponomarev (rponom@gmail.com) +April 04, 2008 TODO: - add clamping od accumulated impulse to improve stability @@ -759,11 +875,11 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_SLIDER_CONSTRAINT_H -// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h +// Parsed from BulletDynamics/ConstraintSolver/btSolverBody.h /* -Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org -Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -776,36 +892,63 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H -// #define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H - +// #ifndef BT_SOLVER_BODY_H +// #define BT_SOLVER_BODY_H // #include "LinearMath/btVector3.h" -// #include "btTypedConstraint.h" -// #include "btGeneric6DofConstraint.h" +// #include "LinearMath/btMatrix3x3.h" + +// #include "LinearMath/btAlignedAllocator.h" +// #include "LinearMath/btTransformUtil.h" + +/**Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision */ +// #ifdef BT_USE_SSE +// #endif // + +// #ifdef USE_SIMD -// #ifdef BT_USE_DOUBLE_PRECISION // #else -// #define btGeneric6DofSpringConstraintData2 btGeneric6DofSpringConstraintData -public static final String btGeneric6DofSpringConstraintDataName = "btGeneric6DofSpringConstraintData"; -// Targeting ../BulletDynamics/btGeneric6DofSpringConstraint.java +// #define btSimdScalar btScalar +// Targeting ../BulletDynamics/btSolverBody.java -// Targeting ../BulletDynamics/btGeneric6DofSpringConstraintData.java +// #endif //BT_SOLVER_BODY_H -// Targeting ../BulletDynamics/btGeneric6DofSpringConstraintDoubleData2.java +// Parsed from BulletDynamics/ConstraintSolver/btSolverConstraint.h +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ +// #ifndef BT_SOLVER_CONSTRAINT_H +// #define BT_SOLVER_CONSTRAINT_H +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btJacobianEntry.h" +// #include "LinearMath/btAlignedObjectArray.h" +//#define NO_FRICTION_TANGENTIALS 1 +// #include "btSolverBody.h" +// Targeting ../BulletDynamics/btSolverConstraint.java -// #endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H -// Parsed from BulletDynamics/ConstraintSolver/btGeneric6DofSpring2Constraint.h +// #endif //BT_SOLVER_CONSTRAINT_H + + +// Parsed from BulletDynamics/Dynamics/btRigidBody.h /* Bullet Continuous Collision Detection and Physics Library @@ -813,8 +956,8 @@ Added by Roman Ponomarev (rponom@gmail.com) This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -822,81 +965,136 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -/* -2014 May: btGeneric6DofSpring2Constraint is created from the original (2.82.2712) btGeneric6DofConstraint by Gabor Puhr and Tamas Umenhoffer -Pros: -- Much more accurate and stable in a lot of situation. (Especially when a sleeping chain of RBs connected with 6dof2 is pulled) -- Stable and accurate spring with minimal energy loss that works with all of the solvers. (latter is not true for the original 6dof spring) -- Servo motor functionality -- Much more accurate bouncing. 0 really means zero bouncing (not true for the original 6odf) and there is only a minimal energy loss when the value is 1 (because of the solvers' precision) -- Rotation order for the Euler system can be set. (One axis' freedom is still limited to pi/2) +// #ifndef BT_RIGIDBODY_H +// #define BT_RIGIDBODY_H -Cons: -- It is slower than the original 6dof. There is no exact ratio, but half speed is a good estimation. -- At bouncing the correct velocity is calculated, but not the correct position. (it is because of the solver can correct position or velocity, but not both.) -*/ +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btTransform.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" + +public static native @Cast("btScalar") float gDeactivationTime(); public static native void gDeactivationTime(float setter); +public static native @Cast("bool") boolean gDisableDeactivation(); public static native void gDisableDeactivation(boolean setter); + +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btRigidBodyData btRigidBodyFloatData +public static final String btRigidBodyDataName = "btRigidBodyFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION + +/** enum btRigidBodyFlags */ +public static final int + BT_DISABLE_WORLD_GRAVITY = 1, + /**BT_ENABLE_GYROPSCOPIC_FORCE flags is enabled by default in Bullet 2.83 and onwards. + * and it BT_ENABLE_GYROPSCOPIC_FORCE becomes equivalent to BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY + * See Demos/GyroscopicDemo and computeGyroscopicImpulseImplicit */ + BT_ENABLE_GYROSCOPIC_FORCE_EXPLICIT = 2, + BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_WORLD = 4, + BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY = 8, + BT_ENABLE_GYROPSCOPIC_FORCE = BT_ENABLE_GYROSCOPIC_FORCE_IMPLICIT_BODY; +// Targeting ../BulletDynamics/btRigidBody.java + + +// Targeting ../BulletDynamics/btRigidBodyFloatData.java + + +// Targeting ../BulletDynamics/btRigidBodyDoubleData.java -/** 2009 March: btGeneric6DofConstraint refactored by Roman Ponomarev -/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ + + +// #endif //BT_RIGIDBODY_H + + +// Parsed from BulletDynamics/ConstraintSolver/btTypedConstraint.h /* -2007-09-09 -btGeneric6DofConstraint Refactored by Francisco Le?n -email: projectileman@yahoo.com -http://gimpact.sf.net +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2010 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_GENERIC_6DOF_CONSTRAINT2_H -// #define BT_GENERIC_6DOF_CONSTRAINT2_H +// #ifndef BT_TYPED_CONSTRAINT_H +// #define BT_TYPED_CONSTRAINT_H -// #include "LinearMath/btVector3.h" -// #include "btJacobianEntry.h" -// #include "btTypedConstraint.h" +// #include "LinearMath/btScalar.h" +// #include "btSolverConstraint.h" +// #include "BulletDynamics/Dynamics/btRigidBody.h" // #ifdef BT_USE_DOUBLE_PRECISION // #else -// #define btGeneric6DofSpring2ConstraintData2 btGeneric6DofSpring2ConstraintData -public static final String btGeneric6DofSpring2ConstraintDataName = "btGeneric6DofSpring2ConstraintData"; +// #define btTypedConstraintData2 btTypedConstraintFloatData +public static final String btTypedConstraintDataName = "btTypedConstraintFloatData"; // #endif //BT_USE_DOUBLE_PRECISION -/** enum RotateOrder */ +//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility +/** enum btTypedConstraintType */ public static final int - RO_XYZ = 0, - RO_XZY = 1, - RO_YXZ = 2, - RO_YZX = 3, - RO_ZXY = 4, - RO_ZYX = 5; -// Targeting ../BulletDynamics/btRotationalLimitMotor2.java + POINT2POINT_CONSTRAINT_TYPE = 3, + HINGE_CONSTRAINT_TYPE = 4, + CONETWIST_CONSTRAINT_TYPE = 5, + D6_CONSTRAINT_TYPE = 6, + SLIDER_CONSTRAINT_TYPE = 7, + CONTACT_CONSTRAINT_TYPE = 8, + D6_SPRING_CONSTRAINT_TYPE = 9, + GEAR_CONSTRAINT_TYPE = 10, + FIXED_CONSTRAINT_TYPE = 11, + D6_SPRING_2_CONSTRAINT_TYPE = 12, + MAX_CONSTRAINT_TYPE = 13; +/** enum btConstraintParams */ +public static final int + BT_CONSTRAINT_ERP = 1, + BT_CONSTRAINT_STOP_ERP = 2, + BT_CONSTRAINT_CFM = 3, + BT_CONSTRAINT_STOP_CFM = 4; -// Targeting ../BulletDynamics/btTranslationalLimitMotor2.java +// #if 1 +// #define btAssertConstrParams(_par) btAssert(_par) +// #else +// #define btAssertConstrParams(_par) +// Targeting ../BulletDynamics/btJointFeedback.java +// Targeting ../BulletDynamics/btTypedConstraint.java -/** enum bt6DofFlags2 */ -public static final int - BT_6DOF_FLAGS_CFM_STOP2 = 1, - BT_6DOF_FLAGS_ERP_STOP2 = 2, - BT_6DOF_FLAGS_CFM_MOTO2 = 4, - BT_6DOF_FLAGS_ERP_MOTO2 = 8, - BT_6DOF_FLAGS_USE_INFINITE_ERROR = (1<<16); -public static final int BT_6DOF_FLAGS_AXIS_SHIFT2 = 4; -// Targeting ../BulletDynamics/btGeneric6DofSpring2Constraint.java -// Targeting ../BulletDynamics/btGeneric6DofSpring2ConstraintData.java +// returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the limits +// all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD_PI]) +public static native @Cast("btScalar") float btAdjustAngleToLimits(@Cast("btScalar") float angleInRadians, @Cast("btScalar") float angleLowerLimitInRadians, @Cast("btScalar") float angleUpperLimitInRadians); +// Targeting ../BulletDynamics/btTypedConstraintFloatData.java -// Targeting ../BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ + +// #define BT_BACKWARDS_COMPATIBLE_SERIALIZATION +// Targeting ../BulletDynamics/btTypedConstraintData.java + + +// Targeting ../BulletDynamics/btTypedConstraintDoubleData.java + +// clang-format on -// #endif //BT_GENERIC_6DOF_CONSTRAINT_H +// Targeting ../BulletDynamics/btAngularLimit.java + + + +// #endif //BT_TYPED_CONSTRAINT_H // Parsed from BulletDynamics/ConstraintSolver/btUniversalConstraint.h @@ -929,41 +1127,11 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif // BT_UNIVERSAL_CONSTRAINT_H -// Parsed from BulletDynamics/ConstraintSolver/btHinge2Constraint.h - -/* -Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org -Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_HINGE2_CONSTRAINT_H -// #define BT_HINGE2_CONSTRAINT_H - -// #include "LinearMath/btVector3.h" -// #include "btTypedConstraint.h" -// #include "btGeneric6DofSpring2Constraint.h" -// Targeting ../BulletDynamics/btHinge2Constraint.java - - - -// #endif // BT_HINGE2_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btGearConstraint.h +// Parsed from BulletDynamics/Dynamics/btActionInterface.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2012 Advanced Micro Devices, Inc. http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -976,38 +1144,23 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_GEAR_CONSTRAINT_H -// #define BT_GEAR_CONSTRAINT_H - -// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btGearConstraintData btGearConstraintFloatData -public static final String btGearConstraintDataName = "btGearConstraintFloatData"; -// Targeting ../BulletDynamics/btGearConstraint.java - - -// Targeting ../BulletDynamics/btGearConstraintFloatData.java - - -// Targeting ../BulletDynamics/btGearConstraintDoubleData.java - - - +// #ifndef _BT_ACTION_INTERFACE_H +// #define _BT_ACTION_INTERFACE_H +// #include "LinearMath/btScalar.h" +// #include "btRigidBody.h" +// Targeting ../BulletDynamics/btActionInterface.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_GEAR_CONSTRAINT_H +// #endif //_BT_ACTION_INTERFACE_H -// Parsed from BulletDynamics/ConstraintSolver/btFixedConstraint.h +// Parsed from BulletDynamics/Dynamics/btDynamicsWorld.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2013 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1020,90 +1173,42 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_FIXED_CONSTRAINT_H -// #define BT_FIXED_CONSTRAINT_H - -// #include "btGeneric6DofSpring2Constraint.h" -// Targeting ../BulletDynamics/btFixedConstraint.java - - - -// #endif //BT_FIXED_CONSTRAINT_H - - -// Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ +// #ifndef BT_DYNAMICS_WORLD_H +// #define BT_DYNAMICS_WORLD_H -// #ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H -// #define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H -// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +// #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" // #include "BulletDynamics/ConstraintSolver/btContactSolverInfo.h" -// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" -// #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" -// #include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" -// #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" -// Targeting ../BulletDynamics/btSolverAnalyticsData.java - - -// Targeting ../BulletDynamics/btSequentialImpulseConstraintSolver.java - - +// Targeting ../BulletDynamics/btInternalTickCallback.java -// #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_H -// Parsed from BulletDynamics/ConstraintSolver/btSolverConstraint.h +/** enum btDynamicsWorldType */ +public static final int + BT_SIMPLE_DYNAMICS_WORLD = 1, + BT_DISCRETE_DYNAMICS_WORLD = 2, + BT_CONTINUOUS_DYNAMICS_WORLD = 3, + BT_SOFT_RIGID_DYNAMICS_WORLD = 4, + BT_GPU_DYNAMICS_WORLD = 5, + BT_SOFT_MULTIBODY_DYNAMICS_WORLD = 6, + BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD = 7; +// Targeting ../BulletDynamics/btDynamicsWorld.java -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ +// Targeting ../BulletDynamics/btDynamicsWorldDoubleData.java -// #ifndef BT_SOLVER_CONSTRAINT_H -// #define BT_SOLVER_CONSTRAINT_H -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "btJacobianEntry.h" -// #include "LinearMath/btAlignedObjectArray.h" -//#define NO_FRICTION_TANGENTIALS 1 -// #include "btSolverBody.h" -// Targeting ../BulletDynamics/btSolverConstraint.java +// Targeting ../BulletDynamics/btDynamicsWorldFloatData.java -// #endif //BT_SOLVER_CONSTRAINT_H +// #endif //BT_DYNAMICS_WORLD_H -// Parsed from BulletDynamics/ConstraintSolver/btSolverBody.h +// Parsed from BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1116,34 +1221,25 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOLVER_BODY_H -// #define BT_SOLVER_BODY_H -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btMatrix3x3.h" - -// #include "LinearMath/btAlignedAllocator.h" -// #include "LinearMath/btTransformUtil.h" - -/**Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision */ -// #ifdef BT_USE_SSE -// #endif // +// #ifndef BT_DISCRETE_DYNAMICS_WORLD_H +// #define BT_DISCRETE_DYNAMICS_WORLD_H -// #ifdef USE_SIMD +// #include "btDynamicsWorld.h" -// #else -// #define btSimdScalar btScalar -// Targeting ../BulletDynamics/btSolverBody.java +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btThreads.h" +// Targeting ../BulletDynamics/btDiscreteDynamicsWorld.java -// #endif //BT_SOLVER_BODY_H +// #endif //BT_DISCRETE_DYNAMICS_WORLD_H -// Parsed from BulletDynamics/ConstraintSolver/btTypedConstraint.h +// Parsed from BulletDynamics/Dynamics/btDiscreteDynamicsWorldMt.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2010 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1156,82 +1252,28 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TYPED_CONSTRAINT_H -// #define BT_TYPED_CONSTRAINT_H - -// #include "LinearMath/btScalar.h" -// #include "btSolverConstraint.h" -// #include "BulletDynamics/Dynamics/btRigidBody.h" - -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btTypedConstraintData2 btTypedConstraintFloatData -public static final String btTypedConstraintDataName = "btTypedConstraintFloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility -/** enum btTypedConstraintType */ -public static final int - POINT2POINT_CONSTRAINT_TYPE = 3, - HINGE_CONSTRAINT_TYPE = 4, - CONETWIST_CONSTRAINT_TYPE = 5, - D6_CONSTRAINT_TYPE = 6, - SLIDER_CONSTRAINT_TYPE = 7, - CONTACT_CONSTRAINT_TYPE = 8, - D6_SPRING_CONSTRAINT_TYPE = 9, - GEAR_CONSTRAINT_TYPE = 10, - FIXED_CONSTRAINT_TYPE = 11, - D6_SPRING_2_CONSTRAINT_TYPE = 12, - MAX_CONSTRAINT_TYPE = 13; - -/** enum btConstraintParams */ -public static final int - BT_CONSTRAINT_ERP = 1, - BT_CONSTRAINT_STOP_ERP = 2, - BT_CONSTRAINT_CFM = 3, - BT_CONSTRAINT_STOP_CFM = 4; - -// #if 1 -// #define btAssertConstrParams(_par) btAssert(_par) -// #else -// #define btAssertConstrParams(_par) -// Targeting ../BulletDynamics/btJointFeedback.java - - -// Targeting ../BulletDynamics/btTypedConstraint.java - - - -// returns angle in range [-SIMD_2_PI, SIMD_2_PI], closest to one of the limits -// all arguments should be normalized angles (i.e. in range [-SIMD_PI, SIMD_PI]) -public static native @Cast("btScalar") float btAdjustAngleToLimits(@Cast("btScalar") float angleInRadians, @Cast("btScalar") float angleLowerLimitInRadians, @Cast("btScalar") float angleUpperLimitInRadians); -// Targeting ../BulletDynamics/btTypedConstraintFloatData.java - - - - - -/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ - -// #define BT_BACKWARDS_COMPATIBLE_SERIALIZATION -// Targeting ../BulletDynamics/btTypedConstraintData.java - - -// Targeting ../BulletDynamics/btTypedConstraintDoubleData.java +// #ifndef BT_DISCRETE_DYNAMICS_WORLD_MT_H +// #define BT_DISCRETE_DYNAMICS_WORLD_MT_H +// #include "btDiscreteDynamicsWorld.h" +// #include "btSimulationIslandManagerMt.h" -// clang-format on +/// +/// +/// +// #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" +// Targeting ../BulletDynamics/btConstraintSolverPoolMt.java -// Targeting ../BulletDynamics/btAngularLimit.java +// Targeting ../BulletDynamics/btDiscreteDynamicsWorldMt.java -// #endif //BT_TYPED_CONSTRAINT_H +// #endif //BT_DISCRETE_DYNAMICS_WORLD_H -// Parsed from BulletDynamics/ConstraintSolver/btBatchedConstraints.h +// Parsed from BulletDynamics/Dynamics/btSimpleDynamicsWorld.h /* Bullet Continuous Collision Detection and Physics Library @@ -1248,21 +1290,18 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_BATCHED_CONSTRAINTS_H -// #define BT_BATCHED_CONSTRAINTS_H +// #ifndef BT_SIMPLE_DYNAMICS_WORLD_H +// #define BT_SIMPLE_DYNAMICS_WORLD_H -// #include "LinearMath/btThreads.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #include "BulletDynamics/ConstraintSolver/btSolverBody.h" -// #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" -// Targeting ../BulletDynamics/btBatchedConstraints.java +// #include "btDynamicsWorld.h" +// Targeting ../BulletDynamics/btSimpleDynamicsWorld.java -// #endif // BT_BATCHED_CONSTRAINTS_H +// #endif //BT_SIMPLE_DYNAMICS_WORLD_H -// Parsed from BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h +// Parsed from BulletDynamics/Dynamics/btSimulationIslandManagerMt.h /* Bullet Continuous Collision Detection and Physics Library @@ -1270,8 +1309,8 @@ Added by Roman Ponomarev (rponom@gmail.com) This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -1279,54 +1318,46 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H -// #define BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H - -// #include "btSequentialImpulseConstraintSolver.h" -// #include "btBatchedConstraints.h" - +// #ifndef BT_SIMULATION_ISLAND_MANAGER_MT_H +// #define BT_SIMULATION_ISLAND_MANAGER_MT_H -/// -/// -/// -/// -/// -/// -/// -// #include "LinearMath/btThreads.h" -// Targeting ../BulletDynamics/btSequentialImpulseConstraintSolverMt.java +// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" +// Targeting ../BulletDynamics/btSimulationIslandManagerMt.java -// #endif //BT_SEQUENTIAL_IMPULSE_CONSTRAINT_SOLVER_MT_H +// #endif //BT_SIMULATION_ISLAND_MANAGER_H -// Parsed from BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h +// Parsed from BulletDynamics/Vehicle/btRaycastVehicle.h /* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. + * Copyright (c) 2005 Erwin Coumans https://bulletphysics.org + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies. + * Erwin Coumans makes no representations about the suitability + * of this software for any purpose. + * It is provided "as is" without express or implied warranty. */ +// #ifndef BT_RAYCASTVEHICLE_H +// #define BT_RAYCASTVEHICLE_H -// #ifndef BT_NNCG_CONSTRAINT_SOLVER_H -// #define BT_NNCG_CONSTRAINT_SOLVER_H +// #include "BulletDynamics/Dynamics/btRigidBody.h" +// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" +// #include "btVehicleRaycaster.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btWheelInfo.h" +// #include "BulletDynamics/Dynamics/btActionInterface.h" +// Targeting ../BulletDynamics/btRaycastVehicle.java -// #include "btSequentialImpulseConstraintSolver.h" -// Targeting ../BulletDynamics/btNNCGConstraintSolver.java +// Targeting ../BulletDynamics/btDefaultVehicleRaycaster.java -// #endif //BT_NNCG_CONSTRAINT_SOLVER_H + +// #endif //BT_RAYCASTVEHICLE_H // Parsed from BulletDynamics/Vehicle/btVehicleRaycaster.h @@ -1379,111 +1410,6 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_WHEEL_INFO_H -// Parsed from BulletDynamics/Vehicle/btRaycastVehicle.h - -/* - * Copyright (c) 2005 Erwin Coumans https://bulletphysics.org - * - * Permission to use, copy, modify, distribute and sell this software - * and its documentation for any purpose is hereby granted without fee, - * provided that the above copyright notice appear in all copies. - * Erwin Coumans makes no representations about the suitability - * of this software for any purpose. - * It is provided "as is" without express or implied warranty. -*/ -// #ifndef BT_RAYCASTVEHICLE_H -// #define BT_RAYCASTVEHICLE_H - -// #include "BulletDynamics/Dynamics/btRigidBody.h" -// #include "BulletDynamics/ConstraintSolver/btTypedConstraint.h" -// #include "btVehicleRaycaster.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #include "btWheelInfo.h" -// #include "BulletDynamics/Dynamics/btActionInterface.h" -// Targeting ../BulletDynamics/btRaycastVehicle.java - - -// Targeting ../BulletDynamics/btDefaultVehicleRaycaster.java - - - -// #endif //BT_RAYCASTVEHICLE_H - - -// Parsed from BulletDynamics/Featherstone/btMultiBodyJointFeedback.h - -/* -Copyright (c) 2015 Google Inc. - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_MULTIBODY_JOINT_FEEDBACK_H -// #define BT_MULTIBODY_JOINT_FEEDBACK_H - -// #include "LinearMath/btSpatialAlgebra.h" -// Targeting ../BulletDynamics/btMultiBodyJointFeedback.java - - - -// #endif //BT_MULTIBODY_JOINT_FEEDBACK_H - - -// Parsed from BulletDynamics/Featherstone/btMultiBodyLink.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2013 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_MULTIBODY_LINK_H -// #define BT_MULTIBODY_LINK_H - -// #include "LinearMath/btQuaternion.h" -// #include "LinearMath/btVector3.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" - -/** enum btMultiBodyLinkFlags */ -public static final int - BT_MULTIBODYLINKFLAGS_DISABLE_PARENT_COLLISION = 1, - BT_MULTIBODYLINKFLAGS_DISABLE_ALL_PARENT_COLLISION = 2; - -//both defines are now permanently enabled -// #define BT_MULTIBODYLINK_INCLUDE_PLANAR_JOINTS -// #define TEST_SPATIAL_ALGEBRA_LAYER - -// -// Various spatial helper functions -// - -//namespace { - -// #include "LinearMath/btSpatialAlgebra.h" -// Targeting ../BulletDynamics/btMultibodyLink.java - - - -// #endif //BT_MULTIBODY_LINK_H - - // Parsed from BulletDynamics/Featherstone/btMultiBody.h /* @@ -1509,90 +1435,42 @@ Added by Roman Ponomarev (rponom@gmail.com) */ -// #ifndef BT_MULTIBODY_H -// #define BT_MULTIBODY_H - -// #include "LinearMath/btScalar.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btQuaternion.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "LinearMath/btAlignedObjectArray.h" - -/**serialization data, don't change them if you are not familiar with the details of the serialization mechanisms */ -// #ifdef BT_USE_DOUBLE_PRECISION -// #else -// #define btMultiBodyData btMultiBodyFloatData -public static final String btMultiBodyDataName = "btMultiBodyFloatData"; -// #define btMultiBodyLinkData btMultiBodyLinkFloatData -public static final String btMultiBodyLinkDataName = "btMultiBodyLinkFloatData"; -// #endif //BT_USE_DOUBLE_PRECISION - -// #include "btMultiBodyLink.h" -// Targeting ../BulletDynamics/btMultiBody.java - - -// Targeting ../BulletDynamics/btMultiBodyLinkDoubleData.java - - -// Targeting ../BulletDynamics/btMultiBodyLinkFloatData.java - - -// Targeting ../BulletDynamics/btMultiBodyDoubleData.java - - -// Targeting ../BulletDynamics/btMultiBodyFloatData.java - - - -// #endif - - -// Parsed from BulletDynamics/Featherstone/btMultiBodyLinkCollider.h - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2013 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef BT_FEATHERSTONE_LINK_COLLIDER_H -// #define BT_FEATHERSTONE_LINK_COLLIDER_H - -// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +// #ifndef BT_MULTIBODY_H +// #define BT_MULTIBODY_H -// #include "btMultiBody.h" -// #include "LinearMath/btSerializer.h" +// #include "LinearMath/btScalar.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btQuaternion.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "LinearMath/btAlignedObjectArray.h" +/**serialization data, don't change them if you are not familiar with the details of the serialization mechanisms */ // #ifdef BT_USE_DOUBLE_PRECISION // #else -// #define btMultiBodyLinkColliderData btMultiBodyLinkColliderFloatData -public static final String btMultiBodyLinkColliderDataName = "btMultiBodyLinkColliderFloatData"; -// Targeting ../BulletDynamics/btMultiBodyLinkCollider.java +// #define btMultiBodyData btMultiBodyFloatData +public static final String btMultiBodyDataName = "btMultiBodyFloatData"; +// #define btMultiBodyLinkData btMultiBodyLinkFloatData +public static final String btMultiBodyLinkDataName = "btMultiBodyLinkFloatData"; +// #endif //BT_USE_DOUBLE_PRECISION +// #include "btMultiBodyLink.h" +// Targeting ../BulletDynamics/btMultiBody.java -// Targeting ../BulletDynamics/btMultiBodyLinkColliderFloatData.java +// Targeting ../BulletDynamics/btMultiBodyLinkDoubleData.java -// Targeting ../BulletDynamics/btMultiBodyLinkColliderDoubleData.java +// Targeting ../BulletDynamics/btMultiBodyLinkFloatData.java -// clang-format on +// Targeting ../BulletDynamics/btMultiBodyDoubleData.java +// Targeting ../BulletDynamics/btMultiBodyFloatData.java -// #endif //BT_FEATHERSTONE_LINK_COLLIDER_H +// #endif // Parsed from BulletDynamics/Featherstone/btMultiBodyConstraint.h @@ -1644,7 +1522,7 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_MULTIBODY_CONSTRAINT_H -// Parsed from BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h +// Parsed from BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h /* Bullet Continuous Collision Detection and Physics Library @@ -1652,8 +1530,8 @@ Added by Roman Ponomarev (rponom@gmail.com) This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -1661,20 +1539,23 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_MULTIBODY_DYNAMICS_WORLD_H -// #define BT_MULTIBODY_DYNAMICS_WORLD_H +// #ifndef BT_MULTIBODY_CONSTRAINT_SOLVER_H +// #define BT_MULTIBODY_CONSTRAINT_SOLVER_H -// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" -// #include "BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h" +// #include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" +// #include "btMultiBodySolverConstraint.h" -// #define BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY -// Targeting ../BulletDynamics/btMultiBodyDynamicsWorld.java +// #define DIRECTLY_UPDATE_VELOCITY_DURING_SOLVER_ITERATIONS + +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodyConstraintSolver.java -// #endif //BT_MULTIBODY_DYNAMICS_WORLD_H + +// #endif //BT_MULTIBODY_CONSTRAINT_SOLVER_H -// Parsed from BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h +// Parsed from BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h /* Bullet Continuous Collision Detection and Physics Library @@ -1682,8 +1563,8 @@ Added by Roman Ponomarev (rponom@gmail.com) This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -1691,20 +1572,17 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_MULTIBODY_CONSTRAINT_SOLVER_H -// #define BT_MULTIBODY_CONSTRAINT_SOLVER_H - -// #include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h" -// #include "btMultiBodySolverConstraint.h" - -// #define DIRECTLY_UPDATE_VELOCITY_DURING_SOLVER_ITERATIONS +// #ifndef BT_MULTIBODY_DYNAMICS_WORLD_H +// #define BT_MULTIBODY_DYNAMICS_WORLD_H -// #include "btMultiBodyConstraint.h" -// Targeting ../BulletDynamics/btMultiBodyConstraintSolver.java +// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" +// #include "BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h" +// #define BT_USE_VIRTUAL_CLEARFORCES_AND_GRAVITY +// Targeting ../BulletDynamics/btMultiBodyDynamicsWorld.java -// #endif //BT_MULTIBODY_CONSTRAINT_SOLVER_H +// #endif //BT_MULTIBODY_DYNAMICS_WORLD_H // Parsed from BulletDynamics/Featherstone/btMultiBodySolverConstraint.h @@ -1798,6 +1676,33 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_MULTIBODY_GEAR_CONSTRAINT_H +// Parsed from BulletDynamics/Featherstone/btMultiBodyJointFeedback.h + +/* +Copyright (c) 2015 Google Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_JOINT_FEEDBACK_H +// #define BT_MULTIBODY_JOINT_FEEDBACK_H + +// #include "LinearMath/btSpatialAlgebra.h" +// Targeting ../BulletDynamics/btMultiBodyJointFeedback.java + + + +// #endif //BT_MULTIBODY_JOINT_FEEDBACK_H + + // Parsed from BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.h /* @@ -1856,7 +1761,54 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_MULTIBODY_JOINT_MOTOR_H -// Parsed from BulletDynamics/Featherstone/btMultiBodyPoint2Point.h +// Parsed from BulletDynamics/Featherstone/btMultiBodyLink.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_LINK_H +// #define BT_MULTIBODY_LINK_H + +// #include "LinearMath/btQuaternion.h" +// #include "LinearMath/btVector3.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" + +/** enum btMultiBodyLinkFlags */ +public static final int + BT_MULTIBODYLINKFLAGS_DISABLE_PARENT_COLLISION = 1, + BT_MULTIBODYLINKFLAGS_DISABLE_ALL_PARENT_COLLISION = 2; + +//both defines are now permanently enabled +// #define BT_MULTIBODYLINK_INCLUDE_PLANAR_JOINTS +// #define TEST_SPATIAL_ALGEBRA_LAYER + +// +// Various spatial helper functions +// + +//namespace { + +// #include "LinearMath/btSpatialAlgebra.h" +// Targeting ../BulletDynamics/btMultibodyLink.java + + + +// #endif //BT_MULTIBODY_LINK_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyLinkCollider.h /* Bullet Continuous Collision Detection and Physics Library @@ -1873,20 +1825,71 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -/**This file was written by Erwin Coumans */ +// #ifndef BT_FEATHERSTONE_LINK_COLLIDER_H +// #define BT_FEATHERSTONE_LINK_COLLIDER_H -// #ifndef BT_MULTIBODY_POINT2POINT_H -// #define BT_MULTIBODY_POINT2POINT_H +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" -// #include "btMultiBodyConstraint.h" -// Targeting ../BulletDynamics/btMultiBodyPoint2Point.java +// #include "btMultiBody.h" +// #include "LinearMath/btSerializer.h" +// #ifdef BT_USE_DOUBLE_PRECISION +// #else +// #define btMultiBodyLinkColliderData btMultiBodyLinkColliderFloatData +public static final String btMultiBodyLinkColliderDataName = "btMultiBodyLinkColliderFloatData"; +// Targeting ../BulletDynamics/btMultiBodyLinkCollider.java -// #endif //BT_MULTIBODY_POINT2POINT_H +// Targeting ../BulletDynamics/btMultiBodyLinkColliderFloatData.java -// Parsed from BulletDynamics/Featherstone/btMultiBodySliderConstraint.h +// Targeting ../BulletDynamics/btMultiBodyLinkColliderDoubleData.java + + + +// clang-format on + + + + + +// #endif //BT_FEATHERSTONE_LINK_COLLIDER_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2018 Google Inc. http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H +// #define BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H + +// #include "LinearMath/btMatrixX.h" +// #include "LinearMath/btThreads.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" +// Targeting ../BulletDynamics/btMLCPSolverInterface.java + + +// Targeting ../BulletDynamics/btMultiBodyMLCPConstraintSolver.java + + + +// #endif // BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H + + +// Parsed from BulletDynamics/Featherstone/btMultiBodyPoint2Point.h /* Bullet Continuous Collision Detection and Physics Library @@ -1905,22 +1908,22 @@ Added by Roman Ponomarev (rponom@gmail.com) /**This file was written by Erwin Coumans */ -// #ifndef BT_MULTIBODY_SLIDER_CONSTRAINT_H -// #define BT_MULTIBODY_SLIDER_CONSTRAINT_H +// #ifndef BT_MULTIBODY_POINT2POINT_H +// #define BT_MULTIBODY_POINT2POINT_H // #include "btMultiBodyConstraint.h" -// Targeting ../BulletDynamics/btMultiBodySliderConstraint.java +// Targeting ../BulletDynamics/btMultiBodyPoint2Point.java -// #endif //BT_MULTIBODY_SLIDER_CONSTRAINT_H +// #endif //BT_MULTIBODY_POINT2POINT_H -// Parsed from BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h +// Parsed from BulletDynamics/Featherstone/btMultiBodySliderConstraint.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2018 Erwin Coumans http://bulletphysics.org +Copyright (c) 2013 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1935,22 +1938,22 @@ Added by Roman Ponomarev (rponom@gmail.com) /**This file was written by Erwin Coumans */ -// #ifndef BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H -// #define BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H +// #ifndef BT_MULTIBODY_SLIDER_CONSTRAINT_H +// #define BT_MULTIBODY_SLIDER_CONSTRAINT_H // #include "btMultiBodyConstraint.h" -// Targeting ../BulletDynamics/btMultiBodySphericalJointMotor.java +// Targeting ../BulletDynamics/btMultiBodySliderConstraint.java -// #endif //BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H +// #endif //BT_MULTIBODY_SLIDER_CONSTRAINT_H -// Parsed from BulletDynamics/Featherstone/btMultiBodyMLCPConstraintSolver.h +// Parsed from BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2018 Google Inc. http://bulletphysics.org +Copyright (c) 2018 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -1963,20 +1966,17 @@ Added by Roman Ponomarev (rponom@gmail.com) 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H -// #define BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H - -// #include "LinearMath/btMatrixX.h" -// #include "LinearMath/btThreads.h" -// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" -// Targeting ../BulletDynamics/btMLCPSolverInterface.java +/**This file was written by Erwin Coumans */ +// #ifndef BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H +// #define BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H -// Targeting ../BulletDynamics/btMultiBodyMLCPConstraintSolver.java +// #include "btMultiBodyConstraint.h" +// Targeting ../BulletDynamics/btMultiBodySphericalJointMotor.java -// #endif // BT_MULTIBODY_MLCP_CONSTRAINT_SOLVER_H +// #endif //BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H // Parsed from BulletDynamics/MLCPSolvers/btDantzigSolver.h diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index aa708ea2754..956840024d6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -105,45 +105,183 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #endif //BT_OBJECT_ARRAY__ -// Parsed from BulletSoftBody/btSparseSDF.h +// Parsed from BulletSoftBody/btDeformableBackwardEulerObjective.h /* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: +// #ifndef BT_BACKWARD_EULER_OBJECTIVE_H +// #define BT_BACKWARD_EULER_OBJECTIVE_H +//#include "btConjugateGradient.h" +// #include "btDeformableLagrangianForce.h" +// #include "btDeformableMassSpringForce.h" +// #include "btDeformableGravityForce.h" +// #include "btDeformableCorotatedForce.h" +// #include "btDeformableMousePickingForce.h" +// #include "btDeformableLinearElasticityForce.h" +// #include "btDeformableNeoHookeanForce.h" +// #include "btDeformableContactProjection.h" +// #include "btPreconditioner.h" +// #include "btDeformableMultiBodyDynamicsWorld.h" +// #include "LinearMath/btQuickprof.h" +// Targeting ../BulletSoftBody/btDeformableBackwardEulerObjective.java -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ -/**btSparseSdf implementation by Nathanael Presson */ -// #ifndef BT_SPARSE_SDF_H -// #define BT_SPARSE_SDF_H -// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" -// #include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" +// #endif /* btBackwardEulerObjective_h */ -// Fast Hash -// #if !defined(get16bits) -// #define get16bits(d) ((((unsigned int)(((const unsigned char*)(d))[1])) << 8) + (unsigned int)(((const unsigned char*)(d))[0])) -// #endif -// -// super hash function by Paul Hsieh -// -public static native @Cast("unsigned int") int HsiehHash(@Cast("const char*") BytePointer data, int len); -public static native @Cast("unsigned int") int HsiehHash(String data, int len); -// Targeting ../BulletSoftBody/btSparseSdf_3.java +// Parsed from BulletSoftBody/btDeformableBodySolver.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ +// #ifndef BT_DEFORMABLE_BODY_SOLVERS_H +// #define BT_DEFORMABLE_BODY_SOLVERS_H + +// #include "btSoftBodySolvers.h" +// #include "btDeformableBackwardEulerObjective.h" +// #include "btDeformableMultiBodyDynamicsWorld.h" +// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" +// #include "btConjugateResidual.h" +// #include "btConjugateGradient.h" +// Targeting ../BulletSoftBody/btCollisionObjectWrapper.java -// #endif //BT_SPARSE_SDF_H +// Targeting ../BulletSoftBody/btDeformableBodySolver.java + + + +// #endif /* btDeformableBodySolver_h */ + + +// Parsed from BulletSoftBody/btDeformableLagrangianForce.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_LAGRANGIAN_FORCE_H +// #define BT_DEFORMABLE_LAGRANGIAN_FORCE_H + +// #include "btSoftBody.h" +// #include +// #include + +/** enum btDeformableLagrangianForceType */ +public static final int + BT_GRAVITY_FORCE = 1, + BT_MASSSPRING_FORCE = 2, + BT_COROTATED_FORCE = 3, + BT_NEOHOOKEAN_FORCE = 4, + BT_LINEAR_ELASTICITY_FORCE = 5, + BT_MOUSE_PICKING_FORCE = 6; + +public static native double randomDouble(double low, double high); +// Targeting ../BulletSoftBody/btDeformableLagrangianForce.java + + +// #endif /* BT_DEFORMABLE_LAGRANGIAN_FORCE */ + + +// Parsed from BulletSoftBody/btDeformableMultiBodyConstraintSolver.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H +// #define BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H + +// #include "btDeformableBodySolver.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" +// Targeting ../BulletSoftBody/btDeformableMultiBodyConstraintSolver.java + + + +// #endif /* BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H */ + + +// Parsed from BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H +// #define BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H + +// #include "btSoftMultiBodyDynamicsWorld.h" +// #include "btDeformableLagrangianForce.h" +// #include "btDeformableMassSpringForce.h" +// #include "btDeformableBodySolver.h" +// #include "btDeformableMultiBodyConstraintSolver.h" +// #include "btSoftBodyHelpers.h" +// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" +// #include +// Targeting ../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java + + + +// #endif //BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H // Parsed from BulletSoftBody/btSoftBody.h @@ -199,11 +337,11 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #endif //_BT_SOFT_BODY_H -// Parsed from BulletSoftBody/btSoftRigidDynamicsWorld.h +// Parsed from BulletSoftBody/btSoftBodyHelpers.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -216,23 +354,27 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOFT_RIGID_DYNAMICS_WORLD_H -// #define BT_SOFT_RIGID_DYNAMICS_WORLD_H +// #ifndef BT_SOFT_BODY_HELPERS_H +// #define BT_SOFT_BODY_HELPERS_H -// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" // #include "btSoftBody.h" -// Targeting ../BulletSoftBody/btSoftRigidDynamicsWorld.java +// #include +// #include +// Targeting ../BulletSoftBody/fDrawFlags.java +// Targeting ../BulletSoftBody/btSoftBodyHelpers.java -// #endif //BT_SOFT_RIGID_DYNAMICS_WORLD_H -// Parsed from BulletSoftBody/btSoftBodyHelpers.h +// #endif //BT_SOFT_BODY_HELPERS_H + + +// Parsed from BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -245,23 +387,18 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOFT_BODY_HELPERS_H -// #define BT_SOFT_BODY_HELPERS_H - -// #include "btSoftBody.h" -// #include -// #include -// Targeting ../BulletSoftBody/fDrawFlags.java - +// #ifndef BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION +// #define BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION -// Targeting ../BulletSoftBody/btSoftBodyHelpers.java +// #include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" +// Targeting ../BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java -// #endif //BT_SOFT_BODY_HELPERS_H +// #endif //BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION -// Parsed from BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h +// Parsed from BulletSoftBody/btSoftBodySolverVertexBuffer.h /* Bullet Continuous Collision Detection and Physics Library @@ -278,15 +415,16 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION -// #define BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION +// #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H +// #define BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H +// Targeting ../BulletSoftBody/btVertexBufferDescriptor.java -// #include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" -// Targeting ../BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java +// Targeting ../BulletSoftBody/btCPUVertexBufferDescriptor.java -// #endif //BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION + +// #endif // #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H // Parsed from BulletSoftBody/btSoftBodySolvers.h @@ -352,108 +490,7 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #endif //BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H -// Parsed from BulletSoftBody/btDeformableBodySolver.h - -/* - Written by Xuchen Han - - Bullet Continuous Collision Detection and Physics Library - Copyright (c) 2019 Google Inc. http://bulletphysics.org - This software is provided 'as-is', without any express or implied warranty. - In no event will the authors be held liable for any damages arising from the use of this software. - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it freely, - subject to the following restrictions: - 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - */ - -// #ifndef BT_DEFORMABLE_BODY_SOLVERS_H -// #define BT_DEFORMABLE_BODY_SOLVERS_H - -// #include "btSoftBodySolvers.h" -// #include "btDeformableBackwardEulerObjective.h" -// #include "btDeformableMultiBodyDynamicsWorld.h" -// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" -// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" -// #include "btConjugateResidual.h" -// #include "btConjugateGradient.h" -// Targeting ../BulletSoftBody/btCollisionObjectWrapper.java - - -// Targeting ../BulletSoftBody/btDeformableBodySolver.java - - - -// #endif /* btDeformableBodySolver_h */ - - -// Parsed from BulletSoftBody/btDeformableMultiBodyConstraintSolver.h - -/* - Written by Xuchen Han - - Bullet Continuous Collision Detection and Physics Library - Copyright (c) 2019 Google Inc. http://bulletphysics.org - This software is provided 'as-is', without any express or implied warranty. - In no event will the authors be held liable for any damages arising from the use of this software. - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it freely, - subject to the following restrictions: - 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - */ - -// #ifndef BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H -// #define BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H - -// #include "btDeformableBodySolver.h" -// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" -// Targeting ../BulletSoftBody/btDeformableMultiBodyConstraintSolver.java - - - -// #endif /* BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H */ - - -// Parsed from BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h - -/* - Written by Xuchen Han - - Bullet Continuous Collision Detection and Physics Library - Copyright (c) 2019 Google Inc. http://bulletphysics.org - This software is provided 'as-is', without any express or implied warranty. - In no event will the authors be held liable for any damages arising from the use of this software. - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it freely, - subject to the following restrictions: - 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - */ - -// #ifndef BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H -// #define BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H - -// #include "btSoftMultiBodyDynamicsWorld.h" -// #include "btDeformableLagrangianForce.h" -// #include "btDeformableMassSpringForce.h" -// #include "btDeformableBodySolver.h" -// #include "btDeformableMultiBodyConstraintSolver.h" -// #include "btSoftBodyHelpers.h" -// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" -// #include -// Targeting ../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java - - - -// #endif //BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H - - -// Parsed from BulletSoftBody/btSoftBodySolverVertexBuffer.h +// Parsed from BulletSoftBody/btSoftRigidDynamicsWorld.h /* Bullet Continuous Collision Detection and Physics Library @@ -470,94 +507,57 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H -// #define BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H -// Targeting ../BulletSoftBody/btVertexBufferDescriptor.java - +// #ifndef BT_SOFT_RIGID_DYNAMICS_WORLD_H +// #define BT_SOFT_RIGID_DYNAMICS_WORLD_H -// Targeting ../BulletSoftBody/btCPUVertexBufferDescriptor.java +// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" +// #include "btSoftBody.h" +// Targeting ../BulletSoftBody/btSoftRigidDynamicsWorld.java -// #endif // #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H +// #endif //BT_SOFT_RIGID_DYNAMICS_WORLD_H -// Parsed from BulletSoftBody/btDeformableBackwardEulerObjective.h +// Parsed from BulletSoftBody/btSparseSDF.h /* - Written by Xuchen Han - - Bullet Continuous Collision Detection and Physics Library - Copyright (c) 2019 Google Inc. http://bulletphysics.org - This software is provided 'as-is', without any express or implied warranty. - In no event will the authors be held liable for any damages arising from the use of this software. - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it freely, - subject to the following restrictions: - 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - */ - -// #ifndef BT_BACKWARD_EULER_OBJECTIVE_H -// #define BT_BACKWARD_EULER_OBJECTIVE_H -//#include "btConjugateGradient.h" -// #include "btDeformableLagrangianForce.h" -// #include "btDeformableMassSpringForce.h" -// #include "btDeformableGravityForce.h" -// #include "btDeformableCorotatedForce.h" -// #include "btDeformableMousePickingForce.h" -// #include "btDeformableLinearElasticityForce.h" -// #include "btDeformableNeoHookeanForce.h" -// #include "btDeformableContactProjection.h" -// #include "btPreconditioner.h" -// #include "btDeformableMultiBodyDynamicsWorld.h" -// #include "LinearMath/btQuickprof.h" -// Targeting ../BulletSoftBody/btDeformableBackwardEulerObjective.java - - - -// #endif /* btBackwardEulerObjective_h */ +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: -// Parsed from BulletSoftBody/btDeformableLagrangianForce.h +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**btSparseSdf implementation by Nathanael Presson */ -/* - Written by Xuchen Han - - Bullet Continuous Collision Detection and Physics Library - Copyright (c) 2019 Google Inc. http://bulletphysics.org - This software is provided 'as-is', without any express or implied warranty. - In no event will the authors be held liable for any damages arising from the use of this software. - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it freely, - subject to the following restrictions: - 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - */ +// #ifndef BT_SPARSE_SDF_H +// #define BT_SPARSE_SDF_H -// #ifndef BT_DEFORMABLE_LAGRANGIAN_FORCE_H -// #define BT_DEFORMABLE_LAGRANGIAN_FORCE_H +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +// #include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" -// #include "btSoftBody.h" -// #include -// #include +// Fast Hash -/** enum btDeformableLagrangianForceType */ -public static final int - BT_GRAVITY_FORCE = 1, - BT_MASSSPRING_FORCE = 2, - BT_COROTATED_FORCE = 3, - BT_NEOHOOKEAN_FORCE = 4, - BT_LINEAR_ELASTICITY_FORCE = 5, - BT_MOUSE_PICKING_FORCE = 6; +// #if !defined(get16bits) +// #define get16bits(d) ((((unsigned int)(((const unsigned char*)(d))[1])) << 8) + (unsigned int)(((const unsigned char*)(d))[0])) +// #endif +// +// super hash function by Paul Hsieh +// +public static native @Cast("unsigned int") int HsiehHash(@Cast("const char*") BytePointer data, int len); +public static native @Cast("unsigned int") int HsiehHash(String data, int len); +// Targeting ../BulletSoftBody/btSparseSdf_3.java -public static native double randomDouble(double low, double high); -// Targeting ../BulletSoftBody/btDeformableLagrangianForce.java -// #endif /* BT_DEFORMABLE_LAGRANGIAN_FORCE */ +// #endif //BT_SPARSE_SDF_H } From 784b718139f7b82168a600322e3b5f77a051a875 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 9 Mar 2022 22:50:39 +0800 Subject: [PATCH 50/81] Remove unused code. --- .../main/java/org/bytedeco/bullet/presets/BulletSoftBody.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 1108cc84527..9104f6e114a 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -23,15 +23,12 @@ package org.bytedeco.bullet.presets; import org.bytedeco.javacpp.Loader; -import org.bytedeco.javacpp.annotation.Cast; import org.bytedeco.javacpp.annotation.Platform; import org.bytedeco.javacpp.annotation.Properties; import org.bytedeco.javacpp.presets.javacpp; import org.bytedeco.javacpp.tools.Info; import org.bytedeco.javacpp.tools.InfoMap; import org.bytedeco.javacpp.tools.InfoMapper; -import org.bytedeco.javacpp.FunctionPointer; -import org.bytedeco.javacpp.Pointer; /** * From 4908c769ff12614ce45473038e229cb50977c9b9 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 10 Mar 2022 23:29:19 +0800 Subject: [PATCH 51/81] Complete mapping of BulletCollision library --- .../bullet/presets/BulletCollision.java | 120 +++++++++++++++--- .../bytedeco/bullet/presets/LinearMath.java | 10 ++ 2 files changed, 111 insertions(+), 19 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index f46cf4a5871..f19e862facd 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -51,10 +51,12 @@ "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h", "BulletCollision/BroadphaseCollision/btQuantizedBvh.h", "BulletCollision/BroadphaseCollision/btSimpleBroadphase.h", + "BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h", "BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h", "BulletCollision/NarrowPhaseCollision/btConvexCast.h", "BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h", "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h", + "BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h", "BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h", "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h", "BulletCollision/NarrowPhaseCollision/btGjkEpa3.h", @@ -64,6 +66,7 @@ "BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h", "BulletCollision/NarrowPhaseCollision/btMprPenetration.h", "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h", + "BulletCollision/NarrowPhaseCollision/btPointCollector.h", "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h", "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h", "BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h", @@ -71,24 +74,39 @@ "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h", "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btBoxBoxDetector.h", "BulletCollision/CollisionDispatch/btCollisionConfiguration.h", "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h", "BulletCollision/CollisionDispatch/btCollisionDispatcher.h", "BulletCollision/CollisionDispatch/btCollisionDispatcherMt.h", "BulletCollision/CollisionDispatch/btCollisionObject.h", + "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h", "BulletCollision/CollisionDispatch/btCollisionWorld.h", + "BulletCollision/CollisionDispatch/btCollisionWorldImporter.h", + "BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h", + "BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h", + "BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h", "BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btGhostObject.h", + "BulletCollision/CollisionDispatch/btHashedSimplePairCache.h", "BulletCollision/CollisionDispatch/btInternalEdgeUtility.h", "BulletCollision/CollisionDispatch/btManifoldResult.h", "BulletCollision/CollisionDispatch/btSimulationIslandManager.h", + "BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h", + "BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h", "BulletCollision/CollisionDispatch/btUnionFind.h", + "BulletCollision/CollisionDispatch/SphereTriangleDetector.h", "BulletCollision/CollisionShapes/btBox2dShape.h", "BulletCollision/CollisionShapes/btBoxShape.h", "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h", "BulletCollision/CollisionShapes/btCapsuleShape.h", + "BulletCollision/CollisionShapes/btCollisionMargin.h", "BulletCollision/CollisionShapes/btCollisionShape.h", "BulletCollision/CollisionShapes/btCompoundShape.h", "BulletCollision/CollisionShapes/btConcaveShape.h", @@ -96,12 +114,17 @@ "BulletCollision/CollisionShapes/btConvex2dShape.h", "BulletCollision/CollisionShapes/btConvexHullShape.h", "BulletCollision/CollisionShapes/btConvexInternalShape.h", + "BulletCollision/CollisionShapes/btConvexPointCloudShape.h", "BulletCollision/CollisionShapes/btConvexPolyhedron.h", "BulletCollision/CollisionShapes/btConvexShape.h", "BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h", "BulletCollision/CollisionShapes/btCylinderShape.h", "BulletCollision/CollisionShapes/btEmptyShape.h", "BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h", + "BulletCollision/CollisionShapes/btMaterial.h", + "BulletCollision/CollisionShapes/btMiniSDF.h", + "BulletCollision/CollisionShapes/btMinkowskiSumShape.h", + "BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h", "BulletCollision/CollisionShapes/btMultiSphereShape.h", "BulletCollision/CollisionShapes/btOptimizedBvh.h", "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h", @@ -112,14 +135,32 @@ "BulletCollision/CollisionShapes/btStaticPlaneShape.h", "BulletCollision/CollisionShapes/btStridingMeshInterface.h", "BulletCollision/CollisionShapes/btTetrahedronShape.h", + "BulletCollision/CollisionShapes/btTriangleBuffer.h", "BulletCollision/CollisionShapes/btTriangleCallback.h", "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h", + "BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h", "BulletCollision/CollisionShapes/btTriangleInfoMap.h", "BulletCollision/CollisionShapes/btTriangleMesh.h", "BulletCollision/CollisionShapes/btTriangleMeshShape.h", "BulletCollision/CollisionShapes/btTriangleShape.h", "BulletCollision/CollisionShapes/btUniformScalingShape.h", + "BulletCollision/Gimpact/btBoxCollision.h", + "BulletCollision/Gimpact/btClipPolygon.h", + "BulletCollision/Gimpact/btCompoundFromGimpact.h", + "BulletCollision/Gimpact/btContactProcessing.h", + "BulletCollision/Gimpact/btContactProcessingStructs.h", + "BulletCollision/Gimpact/btGImpactBvh.h", + "BulletCollision/Gimpact/btGImpactBvhStructs.h", + "BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h", + "BulletCollision/Gimpact/btGImpactMassUtil.h", + "BulletCollision/Gimpact/btGImpactQuantizedBvh.h", + "BulletCollision/Gimpact/btGImpactQuantizedBvhStructs.h", "BulletCollision/Gimpact/btGImpactShape.h", + "BulletCollision/Gimpact/btGenericPoolAllocator.h", + "BulletCollision/Gimpact/btGeometryOperations.h", + "BulletCollision/Gimpact/btQuantization.h", + "BulletCollision/Gimpact/btTriangleShapeEx.h", + "BulletCollision/Gimpact/gim_pair.h", }, link = "BulletCollision@.3.20" ) @@ -135,9 +176,12 @@ public void map(InfoMap infoMap) { .put(new Info("bt32BitAxisSweep3").base("btBroadphaseInterface")) .put(new Info("btAxisSweep3").base("btBroadphaseInterface")) - .put(new Info("BT_DECLARE_STACK_ONLY_OBJECT").cppText("#define BT_DECLARE_STACK_ONLY_OBJECT")) - .put(new Info( + "BT_DEBUG_COLLISION_PAIRS", + "BT_DECLARE_STACK_ONLY_OBJECT", + "BT_UINT_MAX", + "SUPPORT_GIMPACT_SHAPE_IMPORT", + "TRI_COLLISION_PROFILING", "btCollisionObjectData", "btOptimizedBvhNodeData", "btPersistentManifoldData", @@ -157,12 +201,27 @@ public void map(InfoMap infoMap) { "__SPU__" ).define(false)) + .put(new Info("btAlignedObjectArray").pointerTypes("BT_QUANTIZED_BVH_NODE_Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("GIM_BVH_DATA_Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("GIM_BVH_TREE_NODE_Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("GIM_CONTACT_Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("GIM_PAIR_Array")) + .put(new Info("btAlignedObjectArray >").pointerTypes("btCell32ArrayArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btBvhSubtreeInfoArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btCell32Array")) .put(new Info("btAlignedObjectArray").pointerTypes("btCollisionObjectArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDbvtStkNNArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDbvtStkNPSArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btFaceArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btIndexedMeshArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btPersistentManifoldArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btQuantizedBvhNodeArray")) + .put(new Info("btDbvt::sStkNN").pointerTypes("btDbvt.sStkNN")) + .put(new Info("btDbvt::sStkNPS").pointerTypes("btDbvt.sStkNPS")) + + .put(new Info("btCollisionObjectWrapper").purify(true)) + .put(new Info("btCollisionWorldImporter.h").linePatterns("struct btContactSolverInfo;").skip()) .put(new Info("btDispatcher.h").linePatterns("class btRigidBody;").skip()) .put(new Info("btPersistentManifold.h").linePatterns("struct btCollisionResult;").skip()) @@ -173,10 +232,50 @@ public void map(InfoMap infoMap) { "DBVT_IPOLICY", "DBVT_PREFIX", "btAABB", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", @@ -186,25 +285,8 @@ public void map(InfoMap infoMap) { "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", "btCollisionWorld::AllHitsRayResultCallback::m_collisionObjects", - "btCompoundShapeChild::m_node", - "btConvexPolyhedron::m_faces", - "btDbvt::allocate", "btDbvt::extractLeaves", - "btDbvt::m_stkStack", - "btDbvt::rayTestInternal", "btDbvtBroadphase::m_rayTestStacks", - "btDbvtProxy", - "btGImpactBoxSet", - "btGImpactMeshShapePart::TrimeshPrimitiveManager", - "btGImpactCompoundShape::CompoundPrimitiveManager", - "btGImpactShapeInterface::getPrimitiveTriangle", - "btHashedOverlappingPairCache::getOverlappingPairArray", - "btNullPairCache::getOverlappingPairArray", - "btOverlappingPairCache::getOverlappingPairArray", - "btPrimitiveManagerBase", - "btSortedOverlappingPairCache::getOverlappingPairArray", - "btSphereSphereCollisionAlgorithm::getAllContactManifolds", - "btTriangleShapeEx", "gContactDestroyedCallback", "gContactEndedCallback", "gContactProcessedCallback", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index e2ac79fc746..e58f75dbf22 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -128,6 +128,8 @@ public void map(InfoMap infoMap) { .put(new Info("btConvexHullComputer::Edge").pointerTypes("btConvexHullComputer.Edge")) .put(new Info("btHashMap").pointerTypes("btHashMap_btHashPtr_voidPointer")) .put(new Info("btAlignedObjectArray >").javaNames("btIntArrayArray")) + .put(new Info("btAlignedObjectArray >").javaNames("btUnsignedIntArrayArray")) + .put(new Info("btAlignedObjectArray >").javaNames("btDoubleArrayArray")) .put(new Info("int4").pointerTypes("Int4")) .put(new Info("btVectorX").pointerTypes("btVectorXf")) .put(new Info("btVectorX").pointerTypes("btVectorXd")) @@ -148,10 +150,18 @@ public void map(InfoMap infoMap) { "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", "btAlignedObjectArray >::findBinarySearch", "btAlignedObjectArray >::findLinearSearch", "btAlignedObjectArray >::findLinearSearch2", "btAlignedObjectArray >::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", From 5602f2929d86ea905464ee29327c2d40be47bdd4 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 10 Mar 2022 23:33:25 +0800 Subject: [PATCH 52/81] Update generated code of bullet preset See parent commit. --- .../BT_BOX_BOX_TRANSFORM_CACHE.java | 51 + .../BT_QUANTIZED_BVH_NODE.java | 60 + .../BT_QUANTIZED_BVH_NODE_Array.java | 92 + .../ConstraintInput.java} | 15 +- .../bullet/BulletCollision/GIM_BVH_DATA.java | 36 + .../BulletCollision/GIM_BVH_DATA_ARRAY.java | 22 + .../BulletCollision/GIM_BVH_DATA_Array.java | 88 + .../BulletCollision/GIM_BVH_TREE_NODE.java | 44 + .../GIM_BVH_TREE_NODE_ARRAY.java | 22 + .../GIM_BVH_TREE_NODE_Array.java | 88 + .../bullet/BulletCollision/GIM_CONTACT.java | 54 + .../BulletCollision/GIM_CONTACT_Array.java | 88 + .../bullet/BulletCollision/GIM_PAIR.java | 43 + .../BulletCollision/GIM_PAIR_Array.java | 88 + .../GIM_QUANTIZED_BVH_NODE_ARRAY.java | 22 + .../BulletCollision/GIM_TRIANGLE_CONTACT.java | 49 + .../bullet/BulletCollision/MyCallback.java | 28 + .../MyInternalTriangleIndexCallback.java | 29 + .../SphereTriangleDetector.java | 32 + .../BulletCollision/btAlignedBox3d.java | 45 + .../btBoxBoxCollisionAlgorithm.java | 54 + .../BulletCollision/btBoxBoxDetector.java | 31 + .../btBvhSubtreeInfoArray.java | 4 - .../bullet/BulletCollision/btBvhTree.java | 59 + .../bullet/BulletCollision/btCell32.java | 36 + .../bullet/BulletCollision/btCell32Array.java | 88 + .../BulletCollision/btCell32ArrayArray.java | 88 + .../btCollisionObjectWrapper.java | 17 +- .../btCollisionWorldImporter.java | 94 + .../btCompoundCollisionAlgorithm.java | 73 + .../btCompoundCompoundCollisionAlgorithm.java | 71 + .../btCompoundFromGimpactShape.java | 34 + .../BulletCollision/btCompoundShapeChild.java | 2 +- .../btConeTwistConstraint.java | 21 + .../BulletCollision/btContactArray.java | 46 + .../btConvexConcaveCollisionAlgorithm.java | 74 + .../btConvexConvexAlgorithm.java | 59 + .../btConvexPlaneCollisionAlgorithm.java | 57 + .../btConvexPointCloudShape.java | 69 + .../BulletCollision/btConvexPolyhedron.java | 2 +- .../btConvexTriangleCallback.java | 41 + .../bullet/BulletCollision/btDbvt.java | 7 +- .../BulletCollision/btDbvtBroadphase.java | 4 +- .../bullet/BulletCollision/btDbvtProxy.java | 37 + .../BulletCollision/btDbvtStkNNArray.java | 88 + .../BulletCollision/btDbvtStkNPSArray.java | 88 + .../bullet/BulletCollision/btFaceArray.java | 88 + .../bullet/BulletCollision/btGImpactBvh.java | 97 + .../btGImpactCollisionAlgorithm.java | 101 + .../btGImpactCompoundShape.java | 35 + .../BulletCollision/btGImpactMeshShape.java | 3 + .../btGImpactMeshShapePart.java | 66 +- .../btGImpactQuantizedBvh.java | 97 + .../btGImpactShapeInterface.java | 6 +- .../BulletCollision/btGearConstraint.java | 21 + .../btGeneric6DofConstraint.java | 21 + .../btGeneric6DofSpringConstraint.java | 21 + .../BulletCollision/btGenericMemoryPool.java | 54 + .../btGenericPoolAllocator.java | 41 + .../bullet/BulletCollision/btGhostObject.java | 61 + .../BulletCollision/btGhostPairCallback.java | 40 + .../btGjkCollisionDescription.java | 37 + .../btHashedOverlappingPairCache.java | 4 +- .../btHashedSimplePairCache.java | 54 + .../BulletCollision/btHingeConstraint.java | 21 + .../bullet/BulletCollision/btMaterial.java | 41 + .../BulletCollision/btMaterialProperties.java | 48 + .../bullet/BulletCollision/btMiniSDF.java | 63 + .../BulletCollision/btMinkowskiSumShape.java | 32 +- .../bullet/BulletCollision/btMultiIndex.java | 36 + .../btMultimaterialTriangleMeshShape.java | 39 + .../BulletCollision/btNullPairCache.java | 2 +- .../btOverlappingPairCache.java | 2 +- .../btPairCachingGhostObject.java | 42 + .../bullet/BulletCollision/btPairSet.java | 37 + .../btPoint2PointConstraint.java | 21 + .../BulletCollision/btPointCollector.java | 44 + .../btPrimitiveManagerBase.java | 34 + .../BulletCollision/btPrimitiveTriangle.java | 64 + .../BulletCollision/btQuantizedBvhTree.java | 76 + .../BulletCollision/btShapeGradients.java | 42 + .../bullet/BulletCollision/btShapeMatrix.java | 38 + .../BulletCollision/btShapePairCallback.java | 23 + .../bullet/BulletCollision/btSimplePair.java | 29 + .../BulletCollision/btSliderConstraint.java | 21 + .../btSortedOverlappingPairCache.java | 4 +- .../btSphereBoxCollisionAlgorithm.java | 58 + .../btSphereSphereCollisionAlgorithm.java | 2 +- .../btSphereTriangleCollisionAlgorithm.java | 56 + .../bullet/BulletCollision/btTriangle.java | 39 + .../BulletCollision/btTriangleBuffer.java | 50 + .../btTriangleIndexVertexMaterialArray.java | 98 + .../BulletCollision/btTriangleShapeEx.java | 51 + .../bullet/LinearMath/btDoubleArrayArray.java | 86 + .../LinearMath/btUnsignedIntArrayArray.java | 86 + .../bullet/global/BulletCollision.java | 2827 +++++++++++++---- .../bullet/global/BulletSoftBody.java | 3 - .../bytedeco/bullet/global/LinearMath.java | 6 + 98 files changed, 6617 insertions(+), 591 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_BOX_BOX_TRANSFORM_CACHE.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_QUANTIZED_BVH_NODE.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_QUANTIZED_BVH_NODE_Array.java rename bullet/src/gen/java/org/bytedeco/bullet/{BulletSoftBody/btCollisionObjectWrapper.java => BulletCollision/ConstraintInput.java} (56%) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_ARRAY.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_QUANTIZED_BVH_NODE_ARRAY.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_TRIANGLE_CONTACT.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/MyCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/MyInternalTriangleIndexCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/SphereTriangleDetector.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedBox3d.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxBoxCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxBoxDetector.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTree.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32ArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorldImporter.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundCompoundCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundFromGimpactShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeTwistConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContactArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexConcaveCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexConvexAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPlaneCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPointCloudShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtProxy.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtStkNNArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtStkNPSArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFaceArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactBvh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactQuantizedBvh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGearConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGeneric6DofConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGeneric6DofSpringConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGenericMemoryPool.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGenericPoolAllocator.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGhostObject.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGhostPairCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkCollisionDescription.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedSimplePairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHingeConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMaterial.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMaterialProperties.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMiniSDF.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiIndex.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultimaterialTriangleMeshShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairCachingGhostObject.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairSet.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoint2PointConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPointCollector.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPrimitiveManagerBase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPrimitiveTriangle.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhTree.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeGradients.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeMatrix.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapePairCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplePair.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSliderConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereBoxCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereTriangleCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangle.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleBuffer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleIndexVertexMaterialArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleShapeEx.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btDoubleArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btUnsignedIntArrayArray.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_BOX_BOX_TRANSFORM_CACHE.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_BOX_BOX_TRANSFORM_CACHE.java new file mode 100644 index 00000000000..b8019a9e051 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_BOX_BOX_TRANSFORM_CACHE.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Class for transforming a model1 to the space of model0 */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class BT_BOX_BOX_TRANSFORM_CACHE extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public BT_BOX_BOX_TRANSFORM_CACHE(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public BT_BOX_BOX_TRANSFORM_CACHE(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public BT_BOX_BOX_TRANSFORM_CACHE position(long position) { + return (BT_BOX_BOX_TRANSFORM_CACHE)super.position(position); + } + @Override public BT_BOX_BOX_TRANSFORM_CACHE getPointer(long i) { + return new BT_BOX_BOX_TRANSFORM_CACHE((Pointer)this).offsetAddress(i); + } + + /** Transforms translation of model1 to model 0 */ + public native @ByRef btVector3 m_T1to0(); public native BT_BOX_BOX_TRANSFORM_CACHE m_T1to0(btVector3 setter); + /** Transforms Rotation of model1 to model 0, equal to R0' * R1 */ + public native @ByRef btMatrix3x3 m_R1to0(); public native BT_BOX_BOX_TRANSFORM_CACHE m_R1to0(btMatrix3x3 setter); + /** Absolute value of m_R1to0 */ + public native @ByRef btMatrix3x3 m_AR(); public native BT_BOX_BOX_TRANSFORM_CACHE m_AR(btMatrix3x3 setter); + + public native void calc_absolute_matrix(); + + public BT_BOX_BOX_TRANSFORM_CACHE() { super((Pointer)null); allocate(); } + private native void allocate(); + + /** Calc the transformation relative 1 to 0. Inverts matrics by transposing */ + public native void calc_from_homogenic(@Const @ByRef btTransform trans0, @Const @ByRef btTransform trans1); + + /** Calcs the full invertion of the matrices. Useful for scaling matrices */ + public native void calc_from_full_invert(@Const @ByRef btTransform trans0, @Const @ByRef btTransform trans1); + + public native @ByVal btVector3 transform(@Const @ByRef btVector3 point); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_QUANTIZED_BVH_NODE.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_QUANTIZED_BVH_NODE.java new file mode 100644 index 00000000000..9b4ca4762c0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_QUANTIZED_BVH_NODE.java @@ -0,0 +1,60 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**btQuantizedBvhNode is a compressed aabb node, 16 bytes. + * Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range). */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class BT_QUANTIZED_BVH_NODE extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public BT_QUANTIZED_BVH_NODE(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public BT_QUANTIZED_BVH_NODE(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public BT_QUANTIZED_BVH_NODE position(long position) { + return (BT_QUANTIZED_BVH_NODE)super.position(position); + } + @Override public BT_QUANTIZED_BVH_NODE getPointer(long i) { + return new BT_QUANTIZED_BVH_NODE((Pointer)this).offsetAddress(i); + } + + //12 bytes + public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native BT_QUANTIZED_BVH_NODE m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native BT_QUANTIZED_BVH_NODE m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); + //4 bytes + public native int m_escapeIndexOrDataIndex(); public native BT_QUANTIZED_BVH_NODE m_escapeIndexOrDataIndex(int setter); + + public BT_QUANTIZED_BVH_NODE() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean isLeafNode(); + + public native int getEscapeIndex(); + + public native void setEscapeIndex(int index); + + public native int getDataIndex(); + + public native void setDataIndex(int index); + + public native @Cast("bool") boolean testQuantizedBoxOverlapp( + @Cast("unsigned short*") ShortPointer quantizedMin, @Cast("unsigned short*") ShortPointer quantizedMax); + public native @Cast("bool") boolean testQuantizedBoxOverlapp( + @Cast("unsigned short*") ShortBuffer quantizedMin, @Cast("unsigned short*") ShortBuffer quantizedMax); + public native @Cast("bool") boolean testQuantizedBoxOverlapp( + @Cast("unsigned short*") short[] quantizedMin, @Cast("unsigned short*") short[] quantizedMax); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_QUANTIZED_BVH_NODE_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_QUANTIZED_BVH_NODE_Array.java new file mode 100644 index 00000000000..36a3ecd704b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/BT_QUANTIZED_BVH_NODE_Array.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class BT_QUANTIZED_BVH_NODE_Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public BT_QUANTIZED_BVH_NODE_Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public BT_QUANTIZED_BVH_NODE_Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public BT_QUANTIZED_BVH_NODE_Array position(long position) { + return (BT_QUANTIZED_BVH_NODE_Array)super.position(position); + } + @Override public BT_QUANTIZED_BVH_NODE_Array getPointer(long i) { + return new BT_QUANTIZED_BVH_NODE_Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") BT_QUANTIZED_BVH_NODE_Array put(@Const @ByRef BT_QUANTIZED_BVH_NODE_Array other); + public BT_QUANTIZED_BVH_NODE_Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public BT_QUANTIZED_BVH_NODE_Array(@Const @ByRef BT_QUANTIZED_BVH_NODE_Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef BT_QUANTIZED_BVH_NODE_Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef BT_QUANTIZED_BVH_NODE at(int n); + + public native @ByRef @Name("operator []") BT_QUANTIZED_BVH_NODE get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "BT_QUANTIZED_BVH_NODE()") BT_QUANTIZED_BVH_NODE fillData); + public native void resize(int newsize); + public native @ByRef BT_QUANTIZED_BVH_NODE expandNonInitializing(); + + public native @ByRef BT_QUANTIZED_BVH_NODE expand(@Const @ByRef(nullValue = "BT_QUANTIZED_BVH_NODE()") BT_QUANTIZED_BVH_NODE fillValue); + public native @ByRef BT_QUANTIZED_BVH_NODE expand(); + + public native void push_back(@Const @ByRef BT_QUANTIZED_BVH_NODE _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef BT_QUANTIZED_BVH_NODE_Array otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ConstraintInput.java similarity index 56% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ConstraintInput.java index 24776ff1606..74341e67358 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCollisionObjectWrapper.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/ConstraintInput.java @@ -1,6 +1,6 @@ // Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE -package org.bytedeco.bullet.BulletSoftBody; +package org.bytedeco.bullet.BulletCollision; import java.nio.*; import org.bytedeco.javacpp.*; @@ -9,17 +9,14 @@ import static org.bytedeco.javacpp.presets.javacpp.*; import org.bytedeco.bullet.LinearMath.*; import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; + import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletSoftBody.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btCollisionObjectWrapper extends Pointer { +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class ConstraintInput extends Pointer { /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionObjectWrapper() { super((Pointer)null); } + public ConstraintInput() { super((Pointer)null); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btCollisionObjectWrapper(Pointer p) { super(p); } + public ConstraintInput(Pointer p) { super(p); } } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA.java new file mode 100644 index 00000000000..c98df030a15 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + //for GIM_PAIR + +/**GIM_BVH_DATA is an internal GIMPACT collision structure to contain axis aligned bounding box */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_BVH_DATA extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public GIM_BVH_DATA() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_BVH_DATA(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_BVH_DATA(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public GIM_BVH_DATA position(long position) { + return (GIM_BVH_DATA)super.position(position); + } + @Override public GIM_BVH_DATA getPointer(long i) { + return new GIM_BVH_DATA((Pointer)this).offsetAddress(i); + } + + public native int m_data(); public native GIM_BVH_DATA m_data(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_ARRAY.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_ARRAY.java new file mode 100644 index 00000000000..660e22940e0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_ARRAY.java @@ -0,0 +1,22 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_BVH_DATA_ARRAY extends GIM_BVH_DATA_Array { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public GIM_BVH_DATA_ARRAY() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_BVH_DATA_ARRAY(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array.java new file mode 100644 index 00000000000..1fcfdd7f740 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_BVH_DATA_Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_BVH_DATA_Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_BVH_DATA_Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public GIM_BVH_DATA_Array position(long position) { + return (GIM_BVH_DATA_Array)super.position(position); + } + @Override public GIM_BVH_DATA_Array getPointer(long i) { + return new GIM_BVH_DATA_Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") GIM_BVH_DATA_Array put(@Const @ByRef GIM_BVH_DATA_Array other); + public GIM_BVH_DATA_Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public GIM_BVH_DATA_Array(@Const @ByRef GIM_BVH_DATA_Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef GIM_BVH_DATA_Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef GIM_BVH_DATA at(int n); + + public native @ByRef @Name("operator []") GIM_BVH_DATA get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "GIM_BVH_DATA()") GIM_BVH_DATA fillData); + public native void resize(int newsize); + public native @ByRef GIM_BVH_DATA expandNonInitializing(); + + public native @ByRef GIM_BVH_DATA expand(@Const @ByRef(nullValue = "GIM_BVH_DATA()") GIM_BVH_DATA fillValue); + public native @ByRef GIM_BVH_DATA expand(); + + public native void push_back(@Const @ByRef GIM_BVH_DATA _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef GIM_BVH_DATA_Array otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE.java new file mode 100644 index 00000000000..9bd490c9b74 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Node Structure for trees */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_BVH_TREE_NODE extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_BVH_TREE_NODE(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_BVH_TREE_NODE(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public GIM_BVH_TREE_NODE position(long position) { + return (GIM_BVH_TREE_NODE)super.position(position); + } + @Override public GIM_BVH_TREE_NODE getPointer(long i) { + return new GIM_BVH_TREE_NODE((Pointer)this).offsetAddress(i); + } + + public GIM_BVH_TREE_NODE() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean isLeafNode(); + + public native int getEscapeIndex(); + + public native void setEscapeIndex(int index); + + public native int getDataIndex(); + + public native void setDataIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java new file mode 100644 index 00000000000..2f3a5ce4777 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java @@ -0,0 +1,22 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_BVH_TREE_NODE_ARRAY extends GIM_BVH_TREE_NODE_Array { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public GIM_BVH_TREE_NODE_ARRAY() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_BVH_TREE_NODE_ARRAY(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array.java new file mode 100644 index 00000000000..d4888fa9158 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_BVH_TREE_NODE_Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_BVH_TREE_NODE_Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_BVH_TREE_NODE_Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public GIM_BVH_TREE_NODE_Array position(long position) { + return (GIM_BVH_TREE_NODE_Array)super.position(position); + } + @Override public GIM_BVH_TREE_NODE_Array getPointer(long i) { + return new GIM_BVH_TREE_NODE_Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") GIM_BVH_TREE_NODE_Array put(@Const @ByRef GIM_BVH_TREE_NODE_Array other); + public GIM_BVH_TREE_NODE_Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public GIM_BVH_TREE_NODE_Array(@Const @ByRef GIM_BVH_TREE_NODE_Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef GIM_BVH_TREE_NODE_Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef GIM_BVH_TREE_NODE at(int n); + + public native @ByRef @Name("operator []") GIM_BVH_TREE_NODE get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "GIM_BVH_TREE_NODE()") GIM_BVH_TREE_NODE fillData); + public native void resize(int newsize); + public native @ByRef GIM_BVH_TREE_NODE expandNonInitializing(); + + public native @ByRef GIM_BVH_TREE_NODE expand(@Const @ByRef(nullValue = "GIM_BVH_TREE_NODE()") GIM_BVH_TREE_NODE fillValue); + public native @ByRef GIM_BVH_TREE_NODE expand(); + + public native void push_back(@Const @ByRef GIM_BVH_TREE_NODE _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef GIM_BVH_TREE_NODE_Array otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT.java new file mode 100644 index 00000000000..e217d80e123 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The GIM_CONTACT is an internal GIMPACT structure, similar to btManifoldPoint. + * \todo: remove and replace GIM_CONTACT by btManifoldPoint. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_CONTACT extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_CONTACT(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_CONTACT(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public GIM_CONTACT position(long position) { + return (GIM_CONTACT)super.position(position); + } + @Override public GIM_CONTACT getPointer(long i) { + return new GIM_CONTACT((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_point(); public native GIM_CONTACT m_point(btVector3 setter); + public native @ByRef btVector3 m_normal(); public native GIM_CONTACT m_normal(btVector3 setter); + public native @Cast("btScalar") float m_depth(); public native GIM_CONTACT m_depth(float setter); //Positive value indicates interpenetration + public native @Cast("btScalar") float m_distance(); public native GIM_CONTACT m_distance(float setter); //Padding not for use + public native int m_feature1(); public native GIM_CONTACT m_feature1(int setter); //Face number + public native int m_feature2(); public native GIM_CONTACT m_feature2(int setter); + public GIM_CONTACT() { super((Pointer)null); allocate(); } + private native void allocate(); + + public GIM_CONTACT(@Const @ByRef GIM_CONTACT contact) { super((Pointer)null); allocate(contact); } + private native void allocate(@Const @ByRef GIM_CONTACT contact); + + public GIM_CONTACT(@Const @ByRef btVector3 point, @Const @ByRef btVector3 normal, + @Cast("btScalar") float depth, int feature1, int feature2) { super((Pointer)null); allocate(point, normal, depth, feature1, feature2); } + private native void allocate(@Const @ByRef btVector3 point, @Const @ByRef btVector3 normal, + @Cast("btScalar") float depth, int feature1, int feature2); + + /** Calcs key for coord classification */ + public native @Cast("unsigned int") int calc_key_contact(); + + public native void interpolate_normals(btVector3 normals, int normal_count); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array.java new file mode 100644 index 00000000000..4deb036ffc9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_CONTACT_Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_CONTACT_Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_CONTACT_Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public GIM_CONTACT_Array position(long position) { + return (GIM_CONTACT_Array)super.position(position); + } + @Override public GIM_CONTACT_Array getPointer(long i) { + return new GIM_CONTACT_Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") GIM_CONTACT_Array put(@Const @ByRef GIM_CONTACT_Array other); + public GIM_CONTACT_Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public GIM_CONTACT_Array(@Const @ByRef GIM_CONTACT_Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef GIM_CONTACT_Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef GIM_CONTACT at(int n); + + public native @ByRef @Name("operator []") GIM_CONTACT get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "GIM_CONTACT()") GIM_CONTACT fillData); + public native void resize(int newsize); + public native @ByRef GIM_CONTACT expandNonInitializing(); + + public native @ByRef GIM_CONTACT expand(@Const @ByRef(nullValue = "GIM_CONTACT()") GIM_CONTACT fillValue); + public native @ByRef GIM_CONTACT expand(); + + public native void push_back(@Const @ByRef GIM_CONTACT _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef GIM_CONTACT_Array otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR.java new file mode 100644 index 00000000000..14ebcca9e32 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + + +/** Overlapping pair */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_PAIR extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_PAIR(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_PAIR(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public GIM_PAIR position(long position) { + return (GIM_PAIR)super.position(position); + } + @Override public GIM_PAIR getPointer(long i) { + return new GIM_PAIR((Pointer)this).offsetAddress(i); + } + + public native int m_index1(); public native GIM_PAIR m_index1(int setter); + public native int m_index2(); public native GIM_PAIR m_index2(int setter); + public GIM_PAIR() { super((Pointer)null); allocate(); } + private native void allocate(); + + public GIM_PAIR(@Const @ByRef GIM_PAIR p) { super((Pointer)null); allocate(p); } + private native void allocate(@Const @ByRef GIM_PAIR p); + + public GIM_PAIR(int index1, int index2) { super((Pointer)null); allocate(index1, index2); } + private native void allocate(int index1, int index2); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array.java new file mode 100644 index 00000000000..cd9aeef8b40 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_PAIR_Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_PAIR_Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_PAIR_Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public GIM_PAIR_Array position(long position) { + return (GIM_PAIR_Array)super.position(position); + } + @Override public GIM_PAIR_Array getPointer(long i) { + return new GIM_PAIR_Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") GIM_PAIR_Array put(@Const @ByRef GIM_PAIR_Array other); + public GIM_PAIR_Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public GIM_PAIR_Array(@Const @ByRef GIM_PAIR_Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef GIM_PAIR_Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef GIM_PAIR at(int n); + + public native @ByRef @Name("operator []") GIM_PAIR get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "GIM_PAIR()") GIM_PAIR fillData); + public native void resize(int newsize); + public native @ByRef GIM_PAIR expandNonInitializing(); + + public native @ByRef GIM_PAIR expand(@Const @ByRef(nullValue = "GIM_PAIR()") GIM_PAIR fillValue); + public native @ByRef GIM_PAIR expand(); + + public native void push_back(@Const @ByRef GIM_PAIR _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef GIM_PAIR_Array otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_QUANTIZED_BVH_NODE_ARRAY.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_QUANTIZED_BVH_NODE_ARRAY.java new file mode 100644 index 00000000000..002378e7b62 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_QUANTIZED_BVH_NODE_ARRAY.java @@ -0,0 +1,22 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_QUANTIZED_BVH_NODE_ARRAY extends BT_QUANTIZED_BVH_NODE_Array { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public GIM_QUANTIZED_BVH_NODE_ARRAY() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_QUANTIZED_BVH_NODE_ARRAY(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_TRIANGLE_CONTACT.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_TRIANGLE_CONTACT.java new file mode 100644 index 00000000000..017e042d908 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_TRIANGLE_CONTACT.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Structure for collision */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class GIM_TRIANGLE_CONTACT extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GIM_TRIANGLE_CONTACT(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public GIM_TRIANGLE_CONTACT(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public GIM_TRIANGLE_CONTACT position(long position) { + return (GIM_TRIANGLE_CONTACT)super.position(position); + } + @Override public GIM_TRIANGLE_CONTACT getPointer(long i) { + return new GIM_TRIANGLE_CONTACT((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_penetration_depth(); public native GIM_TRIANGLE_CONTACT m_penetration_depth(float setter); + public native int m_point_count(); public native GIM_TRIANGLE_CONTACT m_point_count(int setter); + public native @ByRef btVector4 m_separating_normal(); public native GIM_TRIANGLE_CONTACT m_separating_normal(btVector4 setter); + public native @ByRef btVector3 m_points(int i); public native GIM_TRIANGLE_CONTACT m_points(int i, btVector3 setter); + @MemberGetter public native btVector3 m_points(); + + public native void copy_from(@Const @ByRef GIM_TRIANGLE_CONTACT other); + + public GIM_TRIANGLE_CONTACT() { super((Pointer)null); allocate(); } + private native void allocate(); + + public GIM_TRIANGLE_CONTACT(@Const @ByRef GIM_TRIANGLE_CONTACT other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef GIM_TRIANGLE_CONTACT other); + + /** classify points that are closer */ + public native void merge_points(@Const @ByRef btVector4 plane, + @Cast("btScalar") float margin, @Const btVector3 points, int point_count); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/MyCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/MyCallback.java new file mode 100644 index 00000000000..a5e263b6c88 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/MyCallback.java @@ -0,0 +1,28 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class MyCallback extends btTriangleRaycastCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public MyCallback(Pointer p) { super(p); } + + public native int m_ignorePart(); public native MyCallback m_ignorePart(int setter); + public native int m_ignoreTriangleIndex(); public native MyCallback m_ignoreTriangleIndex(int setter); + + public MyCallback(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, int ignorePart, int ignoreTriangleIndex) { super((Pointer)null); allocate(from, to, ignorePart, ignoreTriangleIndex); } + private native void allocate(@Const @ByRef btVector3 from, @Const @ByRef btVector3 to, int ignorePart, int ignoreTriangleIndex); + public native @Cast("btScalar") float reportHit(@Const @ByRef btVector3 hitNormalLocal, @Cast("btScalar") float hitFraction, int partId, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/MyInternalTriangleIndexCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/MyInternalTriangleIndexCallback.java new file mode 100644 index 00000000000..169ffdcd7e8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/MyInternalTriangleIndexCallback.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class MyInternalTriangleIndexCallback extends btInternalTriangleIndexCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public MyInternalTriangleIndexCallback(Pointer p) { super(p); } + + public native @Const btGImpactMeshShape m_gimpactShape(); public native MyInternalTriangleIndexCallback m_gimpactShape(btGImpactMeshShape setter); + public native btCompoundShape m_colShape(); public native MyInternalTriangleIndexCallback m_colShape(btCompoundShape setter); + public native @Cast("btScalar") float m_depth(); public native MyInternalTriangleIndexCallback m_depth(float setter); + + public MyInternalTriangleIndexCallback(btCompoundShape colShape, @Const btGImpactMeshShape meshShape, @Cast("btScalar") float depth) { super((Pointer)null); allocate(colShape, meshShape, depth); } + private native void allocate(btCompoundShape colShape, @Const btGImpactMeshShape meshShape, @Cast("btScalar") float depth); + + public native void internalProcessTriangleIndex(btVector3 triangle, int partId, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/SphereTriangleDetector.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/SphereTriangleDetector.java new file mode 100644 index 00000000000..867c617552c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/SphereTriangleDetector.java @@ -0,0 +1,32 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** sphere-triangle to match the btDiscreteCollisionDetectorInterface */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class SphereTriangleDetector extends btDiscreteCollisionDetectorInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SphereTriangleDetector(Pointer p) { super(p); } + + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw, @Cast("bool") boolean swapResults/*=false*/); + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw); + + public SphereTriangleDetector(btSphereShape sphere, btTriangleShape triangle, @Cast("btScalar") float contactBreakingThreshold) { super((Pointer)null); allocate(sphere, triangle, contactBreakingThreshold); } + private native void allocate(btSphereShape sphere, btTriangleShape triangle, @Cast("btScalar") float contactBreakingThreshold); + + public native @Cast("bool") boolean collide(@Const @ByRef btVector3 sphereCenter, @ByRef btVector3 point, @ByRef btVector3 resultNormal, @Cast("btScalar*") @ByRef FloatPointer depth, @Cast("btScalar*") @ByRef FloatPointer timeOfImpact, @Cast("btScalar") float contactBreakingThreshold); + public native @Cast("bool") boolean collide(@Const @ByRef btVector3 sphereCenter, @ByRef btVector3 point, @ByRef btVector3 resultNormal, @Cast("btScalar*") @ByRef FloatBuffer depth, @Cast("btScalar*") @ByRef FloatBuffer timeOfImpact, @Cast("btScalar") float contactBreakingThreshold); + public native @Cast("bool") boolean collide(@Const @ByRef btVector3 sphereCenter, @ByRef btVector3 point, @ByRef btVector3 resultNormal, @Cast("btScalar*") @ByRef float[] depth, @Cast("btScalar*") @ByRef float[] timeOfImpact, @Cast("btScalar") float contactBreakingThreshold); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedBox3d.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedBox3d.java new file mode 100644 index 00000000000..6b2b89ffa3c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btAlignedBox3d.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btAlignedBox3d extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btAlignedBox3d(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btAlignedBox3d(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btAlignedBox3d position(long position) { + return (btAlignedBox3d)super.position(position); + } + @Override public btAlignedBox3d getPointer(long i) { + return new btAlignedBox3d((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_min(); public native btAlignedBox3d m_min(btVector3 setter); + public native @ByRef btVector3 m_max(); public native btAlignedBox3d m_max(btVector3 setter); + + public native @Const @ByRef btVector3 min(); + + public native @Const @ByRef btVector3 max(); + + public native @Cast("bool") boolean contains(@Const @ByRef btVector3 x); + + public btAlignedBox3d(@Const @ByRef btVector3 mn, @Const @ByRef btVector3 mx) { super((Pointer)null); allocate(mn, mx); } + private native void allocate(@Const @ByRef btVector3 mn, @Const @ByRef btVector3 mx); + + public btAlignedBox3d() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxBoxCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxBoxCollisionAlgorithm.java new file mode 100644 index 00000000000..5dea66a677f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxBoxCollisionAlgorithm.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**box-box collision detection */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBoxBoxCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBoxBoxCollisionAlgorithm(Pointer p) { super(p); } + + public btBoxBoxCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public btBoxBoxCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap) { super((Pointer)null); allocate(mf, ci, body0Wrap, body1Wrap); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxBoxDetector.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxBoxDetector.java new file mode 100644 index 00000000000..0ba6da47dd2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBoxBoxDetector.java @@ -0,0 +1,31 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btBoxBoxDetector wraps the ODE box-box collision detector + * re-distributed under the Zlib license with permission from Russell L. Smith */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBoxBoxDetector extends btDiscreteCollisionDetectorInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBoxBoxDetector(Pointer p) { super(p); } + + public native @Const btBoxShape m_box1(); public native btBoxBoxDetector m_box1(btBoxShape setter); + public native @Const btBoxShape m_box2(); public native btBoxBoxDetector m_box2(btBoxShape setter); + public btBoxBoxDetector(@Const btBoxShape box1, @Const btBoxShape box2) { super((Pointer)null); allocate(box1, box2); } + private native void allocate(@Const btBoxShape box1, @Const btBoxShape box2); + + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw, @Cast("bool") boolean swapResults/*=false*/); + public native void getClosestPoints(@Const @ByRef ClosestPointInput input, @ByRef Result output, btIDebugDraw debugDraw); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoArray.java index c587db25522..fca9c22a718 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhSubtreeInfoArray.java @@ -11,11 +11,7 @@ import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.BulletCollision.*; - //for placement new -// #endif //BT_USE_PLACEMENT_NEW -/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btBvhSubtreeInfoArray extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTree.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTree.java new file mode 100644 index 00000000000..16e2e8170bf --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btBvhTree.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Basic Box tree structure */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btBvhTree extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btBvhTree(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btBvhTree(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btBvhTree position(long position) { + return (btBvhTree)super.position(position); + } + @Override public btBvhTree getPointer(long i) { + return new btBvhTree((Pointer)this).offsetAddress(i); + } + + public btBvhTree() { super((Pointer)null); allocate(); } + private native void allocate(); + + /** prototype functions for box tree management + * \{ */ + public native void build_tree(@ByRef GIM_BVH_DATA_ARRAY primitive_boxes); + + public native void clearNodes(); + + /** node count */ + public native int getNodeCount(); + + /** tells if the node is a leaf */ + public native @Cast("bool") boolean isLeafNode(int nodeindex); + + public native int getNodeData(int nodeindex); + + public native int getLeftNode(int nodeindex); + + public native int getRightNode(int nodeindex); + + public native int getEscapeNodeIndex(int nodeindex); + + public native @Const GIM_BVH_TREE_NODE get_node_pointer(int index/*=0*/); + public native @Const GIM_BVH_TREE_NODE get_node_pointer(); + + /**\} */ +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32.java new file mode 100644 index 00000000000..13388d85aba --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCell32 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btCell32() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCell32(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCell32(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCell32 position(long position) { + return (btCell32)super.position(position); + } + @Override public btCell32 getPointer(long i) { + return new btCell32((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int m_cells(int i); public native btCell32 m_cells(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer m_cells(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32Array.java new file mode 100644 index 00000000000..0043ba4dfe5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32Array.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCell32Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCell32Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCell32Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCell32Array position(long position) { + return (btCell32Array)super.position(position); + } + @Override public btCell32Array getPointer(long i) { + return new btCell32Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btCell32Array put(@Const @ByRef btCell32Array other); + public btCell32Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btCell32Array(@Const @ByRef btCell32Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btCell32Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btCell32 at(int n); + + public native @ByRef @Name("operator []") btCell32 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btCell32()") btCell32 fillData); + public native void resize(int newsize); + public native @ByRef btCell32 expandNonInitializing(); + + public native @ByRef btCell32 expand(@Const @ByRef(nullValue = "btCell32()") btCell32 fillValue); + public native @ByRef btCell32 expand(); + + public native void push_back(@Const @ByRef btCell32 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btCell32Array otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32ArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32ArrayArray.java new file mode 100644 index 00000000000..e7910bf52cb --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCell32ArrayArray.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCell32ArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCell32ArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCell32ArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btCell32ArrayArray position(long position) { + return (btCell32ArrayArray)super.position(position); + } + @Override public btCell32ArrayArray getPointer(long i) { + return new btCell32ArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btCell32ArrayArray put(@Const @ByRef btCell32ArrayArray other); + public btCell32ArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btCell32ArrayArray(@Const @ByRef btCell32ArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btCell32ArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btCell32Array at(int n); + + public native @ByRef @Name("operator []") btCell32Array get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btCell32Array fillData); + public native void resize(int newsize); + public native @ByRef btCell32Array expandNonInitializing(); + + public native @ByRef btCell32Array expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btCell32Array fillValue); + public native @ByRef btCell32Array expand(); + + public native void push_back(@Const @ByRef btCell32Array _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btCell32ArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java index 0ad1ce6da23..923f6f4af0a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionObjectWrapper.java @@ -12,10 +12,21 @@ import static org.bytedeco.bullet.global.BulletCollision.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btCollisionObjectWrapper extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btCollisionObjectWrapper() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btCollisionObjectWrapper(Pointer p) { super(p); } + + public native @Const btCollisionObjectWrapper m_parent(); public native btCollisionObjectWrapper m_parent(btCollisionObjectWrapper setter); + public native @Const btCollisionShape m_shape(); public native btCollisionObjectWrapper m_shape(btCollisionShape setter); + public native @Const btCollisionObject m_collisionObject(); public native btCollisionObjectWrapper m_collisionObject(btCollisionObject setter); + @MemberGetter public native @Const @ByRef btTransform m_worldTransform(); + public native @Const btTransform m_preTransform(); public native btCollisionObjectWrapper m_preTransform(btTransform setter); + public native int m_partId(); public native btCollisionObjectWrapper m_partId(int setter); + public native int m_index(); public native btCollisionObjectWrapper m_index(int setter); + + public native @Const @ByRef btTransform getWorldTransform(); + public native @Const btCollisionObject getCollisionObject(); + public native @Const btCollisionShape getCollisionShape(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorldImporter.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorldImporter.java new file mode 100644 index 00000000000..e26525d0380 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCollisionWorldImporter.java @@ -0,0 +1,94 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCollisionWorldImporter extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCollisionWorldImporter(Pointer p) { super(p); } + + public btCollisionWorldImporter(btCollisionWorld world) { super((Pointer)null); allocate(world); } + private native void allocate(btCollisionWorld world); + + /**delete all memory collision shapes, rigid bodies, constraints etc. allocated during the load. + * make sure you don't use the dynamics world containing objects after you call this method */ + public native void deleteAllData(); + + public native void setVerboseMode(int verboseMode); + + public native int getVerboseMode(); + + // query for data + public native int getNumCollisionShapes(); + public native btCollisionShape getCollisionShapeByIndex(int index); + public native int getNumRigidBodies(); + public native btCollisionObject getRigidBodyByIndex(int index); + + public native int getNumBvhs(); + public native btOptimizedBvh getBvhByIndex(int index); + public native int getNumTriangleInfoMaps(); + public native btTriangleInfoMap getTriangleInfoMapByIndex(int index); + + // queris involving named objects + public native btCollisionShape getCollisionShapeByName(@Cast("const char*") BytePointer name); + public native btCollisionShape getCollisionShapeByName(String name); + public native btCollisionObject getCollisionObjectByName(@Cast("const char*") BytePointer name); + public native btCollisionObject getCollisionObjectByName(String name); + + public native @Cast("const char*") BytePointer getNameForPointer(@Const Pointer ptr); + + /**those virtuals are called by load and can be overridden by the user */ + + //bodies + + public native btCollisionObject createCollisionObject(@Const @ByRef btTransform startTransform, btCollisionShape shape, @Cast("const char*") BytePointer bodyName); + public native btCollisionObject createCollisionObject(@Const @ByRef btTransform startTransform, btCollisionShape shape, String bodyName); + + /**shapes */ + + public native btCollisionShape createPlaneShape(@Const @ByRef btVector3 planeNormal, @Cast("btScalar") float planeConstant); + public native btCollisionShape createBoxShape(@Const @ByRef btVector3 halfExtents); + public native btCollisionShape createSphereShape(@Cast("btScalar") float radius); + public native btCollisionShape createCapsuleShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height); + public native btCollisionShape createCapsuleShapeY(@Cast("btScalar") float radius, @Cast("btScalar") float height); + public native btCollisionShape createCapsuleShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height); + + public native btCollisionShape createCylinderShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height); + public native btCollisionShape createCylinderShapeY(@Cast("btScalar") float radius, @Cast("btScalar") float height); + public native btCollisionShape createCylinderShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height); + public native btCollisionShape createConeShapeX(@Cast("btScalar") float radius, @Cast("btScalar") float height); + public native btCollisionShape createConeShapeY(@Cast("btScalar") float radius, @Cast("btScalar") float height); + public native btCollisionShape createConeShapeZ(@Cast("btScalar") float radius, @Cast("btScalar") float height); + public native btTriangleIndexVertexArray createTriangleMeshContainer(); + public native btBvhTriangleMeshShape createBvhTriangleMeshShape(btStridingMeshInterface trimesh, btOptimizedBvh bvh); + public native btCollisionShape createConvexTriangleMeshShape(btStridingMeshInterface trimesh); +// #ifdef SUPPORT_GIMPACT_SHAPE_IMPORT +// #endif //SUPPORT_GIMPACT_SHAPE_IMPORT + public native btStridingMeshInterfaceData createStridingMeshInterfaceData(btStridingMeshInterfaceData interfaceData); + + public native btConvexHullShape createConvexHullShape(); + public native btCompoundShape createCompoundShape(); + public native btScaledBvhTriangleMeshShape createScaledTrangleMeshShape(btBvhTriangleMeshShape meshShape, @Const @ByRef btVector3 localScalingbtBvhTriangleMeshShape); + + public native btMultiSphereShape createMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") FloatPointer radi, int numSpheres); + public native btMultiSphereShape createMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") FloatBuffer radi, int numSpheres); + public native btMultiSphereShape createMultiSphereShape(@Const btVector3 positions, @Cast("const btScalar*") float[] radi, int numSpheres); + + public native btTriangleIndexVertexArray createMeshInterface(@ByRef btStridingMeshInterfaceData meshData); + + /**acceleration and connectivity structures */ + public native btOptimizedBvh createOptimizedBvh(); + public native btTriangleInfoMap createTriangleInfoMap(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundCollisionAlgorithm.java new file mode 100644 index 00000000000..82e447048ef --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundCollisionAlgorithm.java @@ -0,0 +1,73 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btCompoundCollisionAlgorithm supports collision between CompoundCollisionShapes and other collision shapes */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCompoundCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundCollisionAlgorithm(Pointer p) { super(p); } + + public btCompoundCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped) { super((Pointer)null); allocate(ci, body0Wrap, body1Wrap, isSwapped); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped); + + public native btCollisionAlgorithm getChildAlgorithm(int n); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } + + public static class SwappedCreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public SwappedCreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SwappedCreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SwappedCreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SwappedCreateFunc position(long position) { + return (SwappedCreateFunc)super.position(position); + } + @Override public SwappedCreateFunc getPointer(long i) { + return new SwappedCreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundCompoundCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundCompoundCollisionAlgorithm.java new file mode 100644 index 00000000000..b88252fb9c7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundCompoundCollisionAlgorithm.java @@ -0,0 +1,71 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btCompoundCompoundCollisionAlgorithm supports collision between two btCompoundCollisionShape shapes */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCompoundCompoundCollisionAlgorithm extends btCompoundCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundCompoundCollisionAlgorithm(Pointer p) { super(p); } + + public btCompoundCompoundCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped) { super((Pointer)null); allocate(ci, body0Wrap, body1Wrap, isSwapped); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } + + public static class SwappedCreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public SwappedCreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SwappedCreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SwappedCreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SwappedCreateFunc position(long position) { + return (SwappedCreateFunc)super.position(position); + } + @Override public SwappedCreateFunc getPointer(long i) { + return new SwappedCreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundFromGimpactShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundFromGimpactShape.java new file mode 100644 index 00000000000..d5e116b5085 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundFromGimpactShape.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btCompoundFromGimpactShape extends btCompoundShape { + static { Loader.load(); } + /** Default native constructor. */ + public btCompoundFromGimpactShape() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btCompoundFromGimpactShape(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCompoundFromGimpactShape(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btCompoundFromGimpactShape position(long position) { + return (btCompoundFromGimpactShape)super.position(position); + } + @Override public btCompoundFromGimpactShape getPointer(long i) { + return new btCompoundFromGimpactShape((Pointer)this).offsetAddress(i); + } + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java index e5eaab60655..068e8387f60 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btCompoundShapeChild.java @@ -38,5 +38,5 @@ public class btCompoundShapeChild extends Pointer { public native btCollisionShape m_childShape(); public native btCompoundShapeChild m_childShape(btCollisionShape setter); public native int m_childShapeType(); public native btCompoundShapeChild m_childShapeType(int setter); public native @Cast("btScalar") float m_childMargin(); public native btCompoundShapeChild m_childMargin(float setter); - + public native btDbvtNode m_node(); public native btCompoundShapeChild m_node(btDbvtNode setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeTwistConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeTwistConstraint.java new file mode 100644 index 00000000000..d79523b74cc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConeTwistConstraint.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConeTwistConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btConeTwistConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConeTwistConstraint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContactArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContactArray.java new file mode 100644 index 00000000000..f642f098e5a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContactArray.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btContactArray extends GIM_CONTACT_Array { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btContactArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btContactArray position(long position) { + return (btContactArray)super.position(position); + } + @Override public btContactArray getPointer(long i) { + return new btContactArray((Pointer)this).offsetAddress(i); + } + + public btContactArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void push_contact( + @Const @ByRef btVector3 point, @Const @ByRef btVector3 normal, + @Cast("btScalar") float depth, int feature1, int feature2); + + public native void push_triangle_contacts( + @Const @ByRef GIM_TRIANGLE_CONTACT tricontact, + int feature1, int feature2); + + public native void merge_contacts(@Const @ByRef btContactArray contacts, @Cast("bool") boolean normal_contact_average/*=true*/); + public native void merge_contacts(@Const @ByRef btContactArray contacts); + + public native void merge_contacts_unique(@Const @ByRef btContactArray contacts); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexConcaveCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexConcaveCollisionAlgorithm.java new file mode 100644 index 00000000000..e8a042863d6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexConcaveCollisionAlgorithm.java @@ -0,0 +1,74 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btConvexConcaveCollisionAlgorithm supports collision between convex shapes and (concave) trianges meshes. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexConcaveCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexConcaveCollisionAlgorithm(Pointer p) { super(p); } + + + public btConvexConcaveCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped) { super((Pointer)null); allocate(ci, body0Wrap, body1Wrap, isSwapped); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public native void clearCache(); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } + + public static class SwappedCreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public SwappedCreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SwappedCreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SwappedCreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SwappedCreateFunc position(long position) { + return (SwappedCreateFunc)super.position(position); + } + @Override public SwappedCreateFunc getPointer(long i) { + return new SwappedCreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexConvexAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexConvexAlgorithm.java new file mode 100644 index 00000000000..3efd2933663 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexConvexAlgorithm.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**Enabling USE_SEPDISTANCE_UTIL2 requires 100% reliable distance computation. However, when using large size ratios GJK can be imprecise + * so the distance is not conservative. In that case, enabling this USE_SEPDISTANCE_UTIL2 would result in failing/missing collisions. + * Either improve GJK for large size ratios (testing a 100 units versus a 0.1 unit object) or only enable the util + * for certain pairs that have a small size ratio */ + +//#define USE_SEPDISTANCE_UTIL2 1 + +/**The convexConvexAlgorithm collision algorithm implements time of impact, convex closest points and penetration depth calculations between two convex objects. +/**Multiple contact points are calculated by perturbing the orientation of the smallest object orthogonal to the separating normal. +/**This idea was described by Gino van den Bergen in this forum topic http://www.bulletphysics.com/Bullet/phpBB3/viewtopic.php?f=4&t=288&p=888#p888 */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexConvexAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexConvexAlgorithm(Pointer p) { super(p); } + + public btConvexConvexAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold) { super((Pointer)null); allocate(mf, ci, body0Wrap, body1Wrap, pdSolver, numPerturbationIterations, minimumPointsPerturbationThreshold); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, btConvexPenetrationDepthSolver pdSolver, int numPerturbationIterations, int minimumPointsPerturbationThreshold); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public native void setLowLevelOfDetail(@Cast("bool") boolean useLowLevel); + + public native @Const btPersistentManifold getManifold(); + + @NoOffset public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + + public native btConvexPenetrationDepthSolver m_pdSolver(); public native CreateFunc m_pdSolver(btConvexPenetrationDepthSolver setter); + public native int m_numPerturbationIterations(); public native CreateFunc m_numPerturbationIterations(int setter); + public native int m_minimumPointsPerturbationThreshold(); public native CreateFunc m_minimumPointsPerturbationThreshold(int setter); + + public CreateFunc(btConvexPenetrationDepthSolver pdSolver) { super((Pointer)null); allocate(pdSolver); } + private native void allocate(btConvexPenetrationDepthSolver pdSolver); + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPlaneCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPlaneCollisionAlgorithm.java new file mode 100644 index 00000000000..79aab710b66 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPlaneCollisionAlgorithm.java @@ -0,0 +1,57 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btSphereBoxCollisionAlgorithm provides sphere-box collision detection. + * Other features are frame-coherency (persistent data) and collision response. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexPlaneCollisionAlgorithm extends btCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexPlaneCollisionAlgorithm(Pointer p) { super(p); } + + public btConvexPlaneCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped, int numPerturbationIterations, int minimumPointsPerturbationThreshold) { super((Pointer)null); allocate(mf, ci, body0Wrap, body1Wrap, isSwapped, numPerturbationIterations, minimumPointsPerturbationThreshold); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped, int numPerturbationIterations, int minimumPointsPerturbationThreshold); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void collideSingleContact(@Const @ByRef btQuaternion perturbeRot, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + @NoOffset public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native int m_numPerturbationIterations(); public native CreateFunc m_numPerturbationIterations(int setter); + public native int m_minimumPointsPerturbationThreshold(); public native CreateFunc m_minimumPointsPerturbationThreshold(int setter); + + public CreateFunc() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPointCloudShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPointCloudShape.java new file mode 100644 index 00000000000..b31554a2442 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPointCloudShape.java @@ -0,0 +1,69 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btConvexPointCloudShape implements an implicit convex hull of an array of vertices. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexPointCloudShape extends btPolyhedralConvexAabbCachingShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexPointCloudShape(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btConvexPointCloudShape(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btConvexPointCloudShape position(long position) { + return (btConvexPointCloudShape)super.position(position); + } + @Override public btConvexPointCloudShape getPointer(long i) { + return new btConvexPointCloudShape((Pointer)this).offsetAddress(i); + } + + + public btConvexPointCloudShape() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btConvexPointCloudShape(btVector3 points, int numPoints, @Const @ByRef btVector3 localScaling, @Cast("bool") boolean computeAabb/*=true*/) { super((Pointer)null); allocate(points, numPoints, localScaling, computeAabb); } + private native void allocate(btVector3 points, int numPoints, @Const @ByRef btVector3 localScaling, @Cast("bool") boolean computeAabb/*=true*/); + public btConvexPointCloudShape(btVector3 points, int numPoints, @Const @ByRef btVector3 localScaling) { super((Pointer)null); allocate(points, numPoints, localScaling); } + private native void allocate(btVector3 points, int numPoints, @Const @ByRef btVector3 localScaling); + + public native void setPoints(btVector3 points, int numPoints, @Cast("bool") boolean computeAabb/*=true*/, @Const @ByRef(nullValue = "btVector3(1.f, 1.f, 1.f)") btVector3 localScaling); + public native void setPoints(btVector3 points, int numPoints); + + public native btVector3 getUnscaledPoints(); + + public native int getNumPoints(); + + public native @ByVal btVector3 getScaledPoint(int index); + +// #ifndef __SPU__ + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); +// #endif + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native int getNumVertices(); + public native int getNumEdges(); + public native void getEdge(int i, @ByRef btVector3 pa, @ByRef btVector3 pb); + public native void getVertex(int i, @ByRef btVector3 vtx); + public native int getNumPlanes(); + public native void getPlane(@ByRef btVector3 planeNormal, @ByRef btVector3 planeSupport, int i); + public native @Cast("bool") boolean isInside(@Const @ByRef btVector3 pt, @Cast("btScalar") float tolerance); + + /**in case we receive negative scaling */ + public native void setLocalScaling(@Const @ByRef btVector3 scaling); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java index 00a6c1aba33..43dbf5911d6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexPolyhedron.java @@ -33,7 +33,7 @@ public class btConvexPolyhedron extends Pointer { private native void allocate(); public native @ByRef btVector3Array m_vertices(); public native btConvexPolyhedron m_vertices(btVector3Array setter); - + public native @ByRef btFaceArray m_faces(); public native btConvexPolyhedron m_faces(btFaceArray setter); public native @ByRef btVector3Array m_uniqueEdges(); public native btConvexPolyhedron m_uniqueEdges(btVector3Array setter); public native @ByRef btVector3 m_localCenter(); public native btConvexPolyhedron m_localCenter(btVector3 setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleCallback.java new file mode 100644 index 00000000000..875cae5b84a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btConvexTriangleCallback.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**For each triangle in the concave mesh that overlaps with the AABB of a convex (m_convexProxy), processTriangle is called. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btConvexTriangleCallback extends btTriangleCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btConvexTriangleCallback(Pointer p) { super(p); } + + + public native int m_triangleCount(); public native btConvexTriangleCallback m_triangleCount(int setter); + + public native btPersistentManifold m_manifoldPtr(); public native btConvexTriangleCallback m_manifoldPtr(btPersistentManifold setter); + + public btConvexTriangleCallback(btDispatcher dispatcher, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped) { super((Pointer)null); allocate(dispatcher, body0Wrap, body1Wrap, isSwapped); } + private native void allocate(btDispatcher dispatcher, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped); + + public native void setTimeStepAndCounters(@Cast("btScalar") float collisionMarginTriangle, @Const @ByRef btDispatcherInfo dispatchInfo, @Const btCollisionObjectWrapper convexBodyWrap, @Const btCollisionObjectWrapper triBodyWrap, btManifoldResult resultOut); + + public native void clearWrapperData(); + + public native void processTriangle(btVector3 triangle, int partId, int triangleIndex); + + public native void clearCache(); + + public native @Const @ByRef btVector3 getAabbMin(); + public native @Const @ByRef btVector3 getAabbMax(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java index 39fec13ef3e..43225417cb5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvt.java @@ -188,7 +188,7 @@ public static class IClone extends Pointer { public native int m_leaves(); public native btDbvt m_leaves(int setter); public native @Cast("unsigned") int m_opath(); public native btDbvt m_opath(int setter); - + public native @ByRef btDbvtStkNNArray m_stkStack(); public native btDbvt m_stkStack(btDbvtStkNNArray setter); // Methods public btDbvt() { super((Pointer)null); allocate(); } @@ -225,10 +225,11 @@ public static class IClone extends Pointer { * rayTest is slower than rayTestInternal, because it builds a local stack, using memory allocations, and it recomputes signs/rayDirectionInverses each time */ /**rayTestInternal is faster than rayTest, because it uses a persistent stack (to reduce dynamic memory allocations to a minimum) and it uses precomputed signs/rayInverseDirections * rayTestInternal is used by btDbvtBroadphase to accelerate world ray casts */ - // Helpers public static native int nearest(@Const IntPointer i, @Const sStkNPS a, @Cast("btScalar") float v, int l, int h); public static native int nearest(@Const IntBuffer i, @Const sStkNPS a, @Cast("btScalar") float v, int l, int h); public static native int nearest(@Const int[] i, @Const sStkNPS a, @Cast("btScalar") float v, int l, int h); - + public static native @Name("allocate") int _allocate(@ByRef btIntArray ifree, + @ByRef btDbvtStkNPSArray stock, + @Const @ByRef sStkNPS value); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java index 3ecde0a69a4..a82dead3cc1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtBroadphase.java @@ -39,7 +39,9 @@ public class btDbvtBroadphase extends btBroadphaseInterface { STAGECOUNT = 2; /* Number of stages */ /* Fields */ public native @ByRef btDbvt m_sets(int i); public native btDbvtBroadphase m_sets(int i, btDbvt setter); - @MemberGetter public native btDbvt m_sets(); // Dbvt sets // Stages list + @MemberGetter public native btDbvt m_sets(); // Dbvt sets + public native btDbvtProxy m_stageRoots(int i); public native btDbvtBroadphase m_stageRoots(int i, btDbvtProxy setter); + @MemberGetter public native @Cast("btDbvtProxy**") PointerPointer m_stageRoots(); // Stages list public native btOverlappingPairCache m_paircache(); public native btDbvtBroadphase m_paircache(btOverlappingPairCache setter); // Pair cache public native @Cast("btScalar") float m_prediction(); public native btDbvtBroadphase m_prediction(float setter); // Velocity prediction public native int m_stageCurrent(); public native btDbvtBroadphase m_stageCurrent(int setter); // Current stage diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtProxy.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtProxy.java new file mode 100644 index 00000000000..86a89b1f7c4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtProxy.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// #if DBVT_BP_PROFILE +// #endif + +// +// btDbvtProxy +// +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDbvtProxy extends btBroadphaseProxy { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvtProxy(Pointer p) { super(p); } + + /* Fields */ + //btDbvtAabbMm aabb; + public native btDbvtNode leaf(); public native btDbvtProxy leaf(btDbvtNode setter); + public native btDbvtProxy links(int i); public native btDbvtProxy links(int i, btDbvtProxy setter); + @MemberGetter public native @Cast("btDbvtProxy**") PointerPointer links(); + public native int stage(); public native btDbvtProxy stage(int setter); + /* ctor */ + public btDbvtProxy(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask); } + private native void allocate(@Const @ByRef btVector3 aabbMin, @Const @ByRef btVector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtStkNNArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtStkNNArray.java new file mode 100644 index 00000000000..90ee2bea8dd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtStkNNArray.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDbvtStkNNArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvtStkNNArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDbvtStkNNArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDbvtStkNNArray position(long position) { + return (btDbvtStkNNArray)super.position(position); + } + @Override public btDbvtStkNNArray getPointer(long i) { + return new btDbvtStkNNArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDbvtStkNNArray put(@Const @ByRef btDbvtStkNNArray other); + public btDbvtStkNNArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDbvtStkNNArray(@Const @ByRef btDbvtStkNNArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDbvtStkNNArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDbvt.sStkNN at(int n); + + public native @ByRef @Name("operator []") btDbvt.sStkNN get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btDbvt::sStkNN()") btDbvt.sStkNN fillData); + public native void resize(int newsize); + public native @ByRef btDbvt.sStkNN expandNonInitializing(); + + public native @ByRef btDbvt.sStkNN expand(@Const @ByRef(nullValue = "btDbvt::sStkNN()") btDbvt.sStkNN fillValue); + public native @ByRef btDbvt.sStkNN expand(); + + public native void push_back(@Const @ByRef btDbvt.sStkNN _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDbvtStkNNArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtStkNPSArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtStkNPSArray.java new file mode 100644 index 00000000000..86f140cdedc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btDbvtStkNPSArray.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btDbvtStkNPSArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDbvtStkNPSArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDbvtStkNPSArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDbvtStkNPSArray position(long position) { + return (btDbvtStkNPSArray)super.position(position); + } + @Override public btDbvtStkNPSArray getPointer(long i) { + return new btDbvtStkNPSArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDbvtStkNPSArray put(@Const @ByRef btDbvtStkNPSArray other); + public btDbvtStkNPSArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDbvtStkNPSArray(@Const @ByRef btDbvtStkNPSArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDbvtStkNPSArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDbvt.sStkNPS at(int n); + + public native @ByRef @Name("operator []") btDbvt.sStkNPS get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btDbvt::sStkNPS()") btDbvt.sStkNPS fillData); + public native void resize(int newsize); + public native @ByRef btDbvt.sStkNPS expandNonInitializing(); + + public native @ByRef btDbvt.sStkNPS expand(@Const @ByRef(nullValue = "btDbvt::sStkNPS()") btDbvt.sStkNPS fillValue); + public native @ByRef btDbvt.sStkNPS expand(); + + public native void push_back(@Const @ByRef btDbvt.sStkNPS _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDbvtStkNPSArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFaceArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFaceArray.java new file mode 100644 index 00000000000..aee30ee8768 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btFaceArray.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btFaceArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btFaceArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btFaceArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btFaceArray position(long position) { + return (btFaceArray)super.position(position); + } + @Override public btFaceArray getPointer(long i) { + return new btFaceArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btFaceArray put(@Const @ByRef btFaceArray other); + public btFaceArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btFaceArray(@Const @ByRef btFaceArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btFaceArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btFace at(int n); + + public native @ByRef @Name("operator []") btFace get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btFace()") btFace fillData); + public native void resize(int newsize); + public native @ByRef btFace expandNonInitializing(); + + public native @ByRef btFace expand(@Const @ByRef(nullValue = "btFace()") btFace fillValue); + public native @ByRef btFace expand(); + + public native void push_back(@Const @ByRef btFace _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btFaceArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactBvh.java new file mode 100644 index 00000000000..c3bbf4d08e9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactBvh.java @@ -0,0 +1,97 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Structure for containing Boxes +/** +This class offers an structure for managing a box tree of primitives. +Requires a Primitive prototype (like btPrimitiveManagerBase ) +*/ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGImpactBvh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGImpactBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGImpactBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btGImpactBvh position(long position) { + return (btGImpactBvh)super.position(position); + } + @Override public btGImpactBvh getPointer(long i) { + return new btGImpactBvh((Pointer)this).offsetAddress(i); + } + + /** this constructor doesn't build the tree. you must call buildSet */ + public btGImpactBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + + /** this constructor doesn't build the tree. you must call buildSet */ + public btGImpactBvh(btPrimitiveManagerBase primitive_manager) { super((Pointer)null); allocate(primitive_manager); } + private native void allocate(btPrimitiveManagerBase primitive_manager); + + public native void setPrimitiveManager(btPrimitiveManagerBase primitive_manager); + + public native btPrimitiveManagerBase getPrimitiveManager(); + + /** node manager prototype functions + * \{ +

+ * this attemps to refit the box set. */ + public native void update(); + + /** this rebuild the entire set */ + public native void buildSet(); + + /** returns the indices of the primitives in the m_primitive_manager */ + + /** returns the indices of the primitives in the m_primitive_manager */ + + /** returns the indices of the primitives in the m_primitive_manager */ + public native @Cast("bool") boolean rayQuery( + @Const @ByRef btVector3 ray_dir, @Const @ByRef btVector3 ray_origin, + @ByRef btIntArray collided_results); + + /** tells if this set has hierarcht */ + public native @Cast("bool") boolean hasHierarchy(); + + /** tells if this set is a trimesh */ + public native @Cast("bool") boolean isTrimesh(); + + /** node count */ + public native int getNodeCount(); + + /** tells if the node is a leaf */ + public native @Cast("bool") boolean isLeafNode(int nodeindex); + + public native int getNodeData(int nodeindex); + + public native int getLeftNode(int nodeindex); + + public native int getRightNode(int nodeindex); + + public native int getEscapeNodeIndex(int nodeindex); + + public native void getNodeTriangle(int nodeindex, @ByRef btPrimitiveTriangle triangle); + + public native @Const GIM_BVH_TREE_NODE get_node_pointer(int index/*=0*/); + public native @Const GIM_BVH_TREE_NODE get_node_pointer(); + +// #ifdef TRI_COLLISION_PROFILING +// #endif //TRI_COLLISION_PROFILING + + public static native void find_collision(btGImpactBvh boxset1, @Const @ByRef btTransform trans1, + btGImpactBvh boxset2, @Const @ByRef btTransform trans2, + @ByRef btPairSet collision_pairs); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCollisionAlgorithm.java new file mode 100644 index 00000000000..579e611d664 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCollisionAlgorithm.java @@ -0,0 +1,101 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Collision Algorithm for GImpact Shapes +/** +For register this algorithm in Bullet, proceed as following: + 

{@code
+btCollisionDispatcher * dispatcher = static_cast(m_dynamicsWorld ->getDispatcher());
+btGImpactCollisionAlgorithm::registerAlgorithm(dispatcher);
+ }
+*/ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGImpactCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGImpactCollisionAlgorithm(Pointer p) { super(p); } + + public btGImpactCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap) { super((Pointer)null); allocate(ci, body0Wrap, body1Wrap); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public native btManifoldResult internalGetResultOut(); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } + + /** Use this function for register the algorithm externally */ + public static native void registerAlgorithm(btCollisionDispatcher dispatcher); +// #ifdef TRI_COLLISION_PROFILING +// #endif //TRI_COLLISION_PROFILING + + /** Collides two gimpact shapes + /** + \pre shape0 and shape1 couldn't be btGImpactMeshShape objects + */ + + public native void gimpact_vs_gimpact(@Const btCollisionObjectWrapper body0Wrap, + @Const btCollisionObjectWrapper body1Wrap, + @Const btGImpactShapeInterface shape0, + @Const btGImpactShapeInterface shape1); + + public native void gimpact_vs_shape(@Const btCollisionObjectWrapper body0Wrap, + @Const btCollisionObjectWrapper body1Wrap, + @Const btGImpactShapeInterface shape0, + @Const btCollisionShape shape1, @Cast("bool") boolean swapped); + + public native void gimpact_vs_compoundshape(@Const btCollisionObjectWrapper body0Wrap, + @Const btCollisionObjectWrapper body1Wrap, + @Const btGImpactShapeInterface shape0, + @Const btCompoundShape shape1, @Cast("bool") boolean swapped); + + public native void gimpact_vs_concave( + @Const btCollisionObjectWrapper body0Wrap, + @Const btCollisionObjectWrapper body1Wrap, + @Const btGImpactShapeInterface shape0, + @Const btConcaveShape shape1, @Cast("bool") boolean swapped); + + /** Accessor/Mutator pairs for Part and triangleID */ + public native void setFace0(int value); + public native int getFace0(); + public native void setFace1(int value); + public native int getFace1(); + public native void setPart0(int value); + public native int getPart0(); + public native void setPart1(int value); + public native int getPart1(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCompoundShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCompoundShape.java index ff2566746c7..ed617e41690 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCompoundShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactCompoundShape.java @@ -33,6 +33,37 @@ public class btGImpactCompoundShape extends btGImpactShapeInterface { } /** compound primitive manager */ + @NoOffset public static class CompoundPrimitiveManager extends btPrimitiveManagerBase { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CompoundPrimitiveManager(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CompoundPrimitiveManager(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public CompoundPrimitiveManager position(long position) { + return (CompoundPrimitiveManager)super.position(position); + } + @Override public CompoundPrimitiveManager getPointer(long i) { + return new CompoundPrimitiveManager((Pointer)this).offsetAddress(i); + } + + public native btGImpactCompoundShape m_compoundShape(); public native CompoundPrimitiveManager m_compoundShape(btGImpactCompoundShape setter); + + public CompoundPrimitiveManager(@Const @ByRef CompoundPrimitiveManager compound) { super((Pointer)null); allocate(compound); } + private native void allocate(@Const @ByRef CompoundPrimitiveManager compound); + + public CompoundPrimitiveManager(btGImpactCompoundShape compoundShape) { super((Pointer)null); allocate(compoundShape); } + private native void allocate(btGImpactCompoundShape compoundShape); + + public CompoundPrimitiveManager() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean is_trimesh(); + + public native int get_primitive_count(); + + public native void get_primitive_triangle(int prim_index, @ByRef btPrimitiveTriangle triangle); + } public btGImpactCompoundShape(@Cast("bool") boolean children_has_transform/*=true*/) { super((Pointer)null); allocate(children_has_transform); } private native void allocate(@Cast("bool") boolean children_has_transform/*=true*/); public btGImpactCompoundShape() { super((Pointer)null); allocate(); } @@ -42,8 +73,10 @@ public class btGImpactCompoundShape extends btGImpactShapeInterface { public native @Cast("bool") boolean childrenHasTransform(); /** Obtains the primitive manager */ + public native @Const btPrimitiveManagerBase getPrimitiveManager(); /** Obtains the compopund primitive manager */ + public native CompoundPrimitiveManager getCompoundPrimitiveManager(); /** Gets the number of children */ public native int getNumChildShapes(); @@ -79,6 +112,8 @@ public class btGImpactCompoundShape extends btGImpactShapeInterface { /** Determines if this shape has tetrahedrons */ public native @Cast("bool") boolean needsRetrieveTetrahedrons(); + public native void getBulletTriangle(int prim_index, @ByRef btTriangleShapeEx triangle); + public native void getBulletTetrahedron(int prim_index, @ByRef btTetrahedronShapeEx tetrahedron); /** Calculates the exact inertia tensor for this shape */ diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShape.java index 2cb6463b3bd..2dddb2dfaf4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShape.java @@ -46,6 +46,7 @@ public class btGImpactMeshShape extends btGImpactShapeInterface { public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); /** Obtains the primitive manager */ + public native @Const btPrimitiveManagerBase getPrimitiveManager(); /** Gets the number of children */ public native int getNumChildShapes(); @@ -59,6 +60,8 @@ public class btGImpactMeshShape extends btGImpactShapeInterface { /** Determines if this shape has tetrahedrons */ public native @Cast("bool") boolean needsRetrieveTetrahedrons(); + public native void getBulletTriangle(int prim_index, @ByRef btTriangleShapeEx triangle); + public native void getBulletTetrahedron(int prim_index, @ByRef btTetrahedronShapeEx tetrahedron); /** call when reading child shapes */ diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapePart.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapePart.java index 32e83166522..13e63979f29 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapePart.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactMeshShapePart.java @@ -20,7 +20,7 @@ - You can handle deformable meshes with this shape, by calling postUpdate() every time when changing the mesh vertices.

*/ -@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) public class btGImpactMeshShapePart extends btGImpactShapeInterface { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ @@ -39,6 +39,65 @@ public class btGImpactMeshShapePart extends btGImpactShapeInterface { /** Manages the info from btStridingMeshInterface object and controls the Lock/Unlock mechanism */ + @NoOffset public static class TrimeshPrimitiveManager extends btPrimitiveManagerBase { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public TrimeshPrimitiveManager(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public TrimeshPrimitiveManager(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public TrimeshPrimitiveManager position(long position) { + return (TrimeshPrimitiveManager)super.position(position); + } + @Override public TrimeshPrimitiveManager getPointer(long i) { + return new TrimeshPrimitiveManager((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_margin(); public native TrimeshPrimitiveManager m_margin(float setter); + public native btStridingMeshInterface m_meshInterface(); public native TrimeshPrimitiveManager m_meshInterface(btStridingMeshInterface setter); + public native @ByRef btVector3 m_scale(); public native TrimeshPrimitiveManager m_scale(btVector3 setter); + public native int m_part(); public native TrimeshPrimitiveManager m_part(int setter); + public native int m_lock_count(); public native TrimeshPrimitiveManager m_lock_count(int setter); + public native @Cast("const unsigned char*") BytePointer vertexbase(); public native TrimeshPrimitiveManager vertexbase(BytePointer setter); + public native int numverts(); public native TrimeshPrimitiveManager numverts(int setter); + public native @Cast("PHY_ScalarType") int type(); public native TrimeshPrimitiveManager type(int setter); + public native int stride(); public native TrimeshPrimitiveManager stride(int setter); + public native @Cast("const unsigned char*") BytePointer indexbase(); public native TrimeshPrimitiveManager indexbase(BytePointer setter); + public native int indexstride(); public native TrimeshPrimitiveManager indexstride(int setter); + public native int numfaces(); public native TrimeshPrimitiveManager numfaces(int setter); + public native @Cast("PHY_ScalarType") int indicestype(); public native TrimeshPrimitiveManager indicestype(int setter); + + public TrimeshPrimitiveManager() { super((Pointer)null); allocate(); } + private native void allocate(); + + public TrimeshPrimitiveManager(@Const @ByRef TrimeshPrimitiveManager manager) { super((Pointer)null); allocate(manager); } + private native void allocate(@Const @ByRef TrimeshPrimitiveManager manager); + + public TrimeshPrimitiveManager( + btStridingMeshInterface meshInterface, int part) { super((Pointer)null); allocate(meshInterface, part); } + private native void allocate( + btStridingMeshInterface meshInterface, int part); + + public native void lock(); + + public native void unlock(); + + public native @Cast("bool") boolean is_trimesh(); + + public native int get_primitive_count(); + + public native int get_vertex_count(); + + public native void get_indices(int face_index, @Cast("unsigned int*") @ByRef IntPointer i0, @Cast("unsigned int*") @ByRef IntPointer i1, @Cast("unsigned int*") @ByRef IntPointer i2); + public native void get_indices(int face_index, @Cast("unsigned int*") @ByRef IntBuffer i0, @Cast("unsigned int*") @ByRef IntBuffer i1, @Cast("unsigned int*") @ByRef IntBuffer i2); + public native void get_indices(int face_index, @Cast("unsigned int*") @ByRef int[] i0, @Cast("unsigned int*") @ByRef int[] i1, @Cast("unsigned int*") @ByRef int[] i2); + + public native void get_vertex(@Cast("unsigned int") int vertex_index, @ByRef btVector3 vertex); + + public native void get_primitive_triangle(int prim_index, @ByRef btPrimitiveTriangle triangle); + + public native void get_bullet_triangle(int prim_index, @ByRef btTriangleShapeEx triangle); + } public btGImpactMeshShapePart() { super((Pointer)null); allocate(); } private native void allocate(); @@ -70,6 +129,9 @@ public class btGImpactMeshShapePart extends btGImpactShapeInterface { public native void setChildTransform(int index, @Const @ByRef btTransform transform); /** Obtains the primitive manager */ + public native @Const btPrimitiveManagerBase getPrimitiveManager(); + + public native TrimeshPrimitiveManager getTrimeshPrimitiveManager(); public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); @@ -83,6 +145,8 @@ public class btGImpactMeshShapePart extends btGImpactShapeInterface { /** Determines if this shape has tetrahedrons */ public native @Cast("bool") boolean needsRetrieveTetrahedrons(); + public native void getBulletTriangle(int prim_index, @ByRef btTriangleShapeEx triangle); + public native void getBulletTetrahedron(int prim_index, @ByRef btTetrahedronShapeEx tetrahedron); public native int getVertexCount(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactQuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactQuantizedBvh.java new file mode 100644 index 00000000000..5b6fad76c4e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactQuantizedBvh.java @@ -0,0 +1,97 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Structure for containing Boxes +/** +This class offers an structure for managing a box tree of primitives. +Requires a Primitive prototype (like btPrimitiveManagerBase ) +*/ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGImpactQuantizedBvh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGImpactQuantizedBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGImpactQuantizedBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btGImpactQuantizedBvh position(long position) { + return (btGImpactQuantizedBvh)super.position(position); + } + @Override public btGImpactQuantizedBvh getPointer(long i) { + return new btGImpactQuantizedBvh((Pointer)this).offsetAddress(i); + } + + /** this constructor doesn't build the tree. you must call buildSet */ + public btGImpactQuantizedBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + + /** this constructor doesn't build the tree. you must call buildSet */ + public btGImpactQuantizedBvh(btPrimitiveManagerBase primitive_manager) { super((Pointer)null); allocate(primitive_manager); } + private native void allocate(btPrimitiveManagerBase primitive_manager); + + public native void setPrimitiveManager(btPrimitiveManagerBase primitive_manager); + + public native btPrimitiveManagerBase getPrimitiveManager(); + + /** node manager prototype functions + * \{ +

+ * this attemps to refit the box set. */ + public native void update(); + + /** this rebuild the entire set */ + public native void buildSet(); + + /** returns the indices of the primitives in the m_primitive_manager */ + + /** returns the indices of the primitives in the m_primitive_manager */ + + /** returns the indices of the primitives in the m_primitive_manager */ + public native @Cast("bool") boolean rayQuery( + @Const @ByRef btVector3 ray_dir, @Const @ByRef btVector3 ray_origin, + @ByRef btIntArray collided_results); + + /** tells if this set has hierarcht */ + public native @Cast("bool") boolean hasHierarchy(); + + /** tells if this set is a trimesh */ + public native @Cast("bool") boolean isTrimesh(); + + /** node count */ + public native int getNodeCount(); + + /** tells if the node is a leaf */ + public native @Cast("bool") boolean isLeafNode(int nodeindex); + + public native int getNodeData(int nodeindex); + + public native int getLeftNode(int nodeindex); + + public native int getRightNode(int nodeindex); + + public native int getEscapeNodeIndex(int nodeindex); + + public native void getNodeTriangle(int nodeindex, @ByRef btPrimitiveTriangle triangle); + + public native @Const BT_QUANTIZED_BVH_NODE get_node_pointer(int index/*=0*/); + public native @Const BT_QUANTIZED_BVH_NODE get_node_pointer(); + +// #ifdef TRI_COLLISION_PROFILING +// #endif //TRI_COLLISION_PROFILING + + public static native void find_collision(@Const btGImpactQuantizedBvh boxset1, @Const @ByRef btTransform trans1, + @Const btGImpactQuantizedBvh boxset2, @Const @ByRef btTransform trans2, + @ByRef btPairSet collision_pairs); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactShapeInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactShapeInterface.java index 7a80d160e57..6ed80739915 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactShapeInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGImpactShapeInterface.java @@ -59,11 +59,13 @@ public class btGImpactShapeInterface extends btConcaveShape { public native @Cast("eGIMPACT_SHAPE_TYPE") int getGImpactShapeType(); /** gets boxset */ + public native @Cast("const btGImpactBoxSet*") btGImpactQuantizedBvh getBoxSet(); /** Determines if this class has a hierarchy structure for sorting its primitives */ public native @Cast("bool") boolean hasBoxSet(); /** Obtains the primitive manager */ + public native @Const btPrimitiveManagerBase getPrimitiveManager(); /** Gets the number of children */ public native int getNumChildShapes(); @@ -77,6 +79,8 @@ public class btGImpactShapeInterface extends btConcaveShape { /** Determines if this shape has tetrahedrons */ public native @Cast("bool") boolean needsRetrieveTetrahedrons(); + public native void getBulletTriangle(int prim_index, @ByRef btTriangleShapeEx triangle); + public native void getBulletTetrahedron(int prim_index, @ByRef btTetrahedronShapeEx tetrahedron); /** call when reading child shapes */ @@ -85,7 +89,7 @@ public class btGImpactShapeInterface extends btConcaveShape { public native void unlockChildShapes(); /** if this trimesh */ - + public native void getPrimitiveTriangle(int index, @ByRef btPrimitiveTriangle triangle); /** Retrieves the bound from a child /** diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGearConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGearConstraint.java new file mode 100644 index 00000000000..e26865efe91 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGearConstraint.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGearConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btGearConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGearConstraint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGeneric6DofConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGeneric6DofConstraint.java new file mode 100644 index 00000000000..63078412722 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGeneric6DofConstraint.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGeneric6DofConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btGeneric6DofConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofConstraint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGeneric6DofSpringConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGeneric6DofSpringConstraint.java new file mode 100644 index 00000000000..6a8dcbdac71 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGeneric6DofSpringConstraint.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGeneric6DofSpringConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btGeneric6DofSpringConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGeneric6DofSpringConstraint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGenericMemoryPool.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGenericMemoryPool.java new file mode 100644 index 00000000000..ca927888d58 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGenericMemoryPool.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Generic Pool class */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGenericMemoryPool extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGenericMemoryPool(Pointer p) { super(p); } + + public native @Cast("unsigned char*") BytePointer m_pool(); public native btGenericMemoryPool m_pool(BytePointer setter); //[m_element_size*m_max_element_count]; + public native @Cast("size_t*") SizeTPointer m_free_nodes(); public native btGenericMemoryPool m_free_nodes(SizeTPointer setter); //[m_max_element_count];//! free nodes + public native @Cast("size_t*") SizeTPointer m_allocated_sizes(); public native btGenericMemoryPool m_allocated_sizes(SizeTPointer setter); //[m_max_element_count];//! Number of elements allocated per node + public native @Cast("size_t") long m_allocated_count(); public native btGenericMemoryPool m_allocated_count(long setter); + public native @Cast("size_t") long m_free_nodes_count(); public native btGenericMemoryPool m_free_nodes_count(long setter); + public native void init_pool(@Cast("size_t") long element_size, @Cast("size_t") long element_count); + + public native void end_pool(); + + public btGenericMemoryPool(@Cast("size_t") long element_size, @Cast("size_t") long element_count) { super((Pointer)null); allocate(element_size, element_count); } + private native void allocate(@Cast("size_t") long element_size, @Cast("size_t") long element_count); + + public native @Cast("size_t") long get_pool_capacity(); + + public native @Cast("size_t") long gem_element_size(); + + public native @Cast("size_t") long get_max_element_count(); + + public native @Cast("size_t") long get_allocated_count(); + + public native @Cast("size_t") long get_free_positions_count(); + + public native Pointer get_element_data(@Cast("size_t") long element_index); + + /** Allocates memory in pool + /** + @param size_bytes size in bytes of the buffer + */ + public native @Name("allocate") Pointer _allocate(@Cast("size_t") long size_bytes); + + public native @Cast("bool") boolean freeMemory(Pointer pointer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGenericPoolAllocator.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGenericPoolAllocator.java new file mode 100644 index 00000000000..81711254cfa --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGenericPoolAllocator.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Generic Allocator with pools +/** +General purpose Allocator which can create Memory Pools dynamiacally as needed. +*/ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGenericPoolAllocator extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGenericPoolAllocator(Pointer p) { super(p); } + + public native btGenericMemoryPool m_pools(int i); public native btGenericPoolAllocator m_pools(int i, btGenericMemoryPool setter); + @MemberGetter public native @Cast("btGenericMemoryPool**") PointerPointer m_pools(); + public native @Cast("size_t") long m_pool_count(); public native btGenericPoolAllocator m_pool_count(long setter); + + public native @Cast("size_t") long get_pool_capacity(); + public btGenericPoolAllocator(@Cast("size_t") long pool_element_size, @Cast("size_t") long pool_element_count) { super((Pointer)null); allocate(pool_element_size, pool_element_count); } + private native void allocate(@Cast("size_t") long pool_element_size, @Cast("size_t") long pool_element_count); + + /** Allocates memory in pool + /** + @param size_bytes size in bytes of the buffer + */ + public native @Name("allocate") Pointer _allocate(@Cast("size_t") long size_bytes); + + public native @Cast("bool") boolean freeMemory(Pointer pointer); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGhostObject.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGhostObject.java new file mode 100644 index 00000000000..833dbba2ad8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGhostObject.java @@ -0,0 +1,61 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btGhostObject 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. + * We plan on adding rayTest and other queries for the btGhostObject */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGhostObject extends btCollisionObject { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGhostObject(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGhostObject(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btGhostObject position(long position) { + return (btGhostObject)super.position(position); + } + @Override public btGhostObject getPointer(long i) { + return new btGhostObject((Pointer)this).offsetAddress(i); + } + + public btGhostObject() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void convexSweepTest(@Const btConvexShape castShape, @Const @ByRef btTransform convexFromWorld, @Const @ByRef btTransform convexToWorld, @ByRef btCollisionWorld.ConvexResultCallback resultCallback, @Cast("btScalar") float allowedCcdPenetration/*=0.f*/); + public native void convexSweepTest(@Const btConvexShape castShape, @Const @ByRef btTransform convexFromWorld, @Const @ByRef btTransform convexToWorld, @ByRef btCollisionWorld.ConvexResultCallback resultCallback); + + public native void rayTest(@Const @ByRef btVector3 rayFromWorld, @Const @ByRef btVector3 rayToWorld, @ByRef btCollisionWorld.RayResultCallback resultCallback); + + /**this method is mainly for expert/internal use only. */ + public native void addOverlappingObjectInternal(btBroadphaseProxy otherProxy, btBroadphaseProxy thisProxy/*=0*/); + public native void addOverlappingObjectInternal(btBroadphaseProxy otherProxy); + /**this method is mainly for expert/internal use only. */ + public native void removeOverlappingObjectInternal(btBroadphaseProxy otherProxy, btDispatcher dispatcher, btBroadphaseProxy thisProxy/*=0*/); + public native void removeOverlappingObjectInternal(btBroadphaseProxy otherProxy, btDispatcher dispatcher); + + public native int getNumOverlappingObjects(); + + public native btCollisionObject getOverlappingObject(int index); + + public native @ByRef btCollisionObjectArray getOverlappingPairs(); + + // + // internal cast + // + + public static native @Const btGhostObject upcast(@Const btCollisionObject colObj); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGhostPairCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGhostPairCallback.java new file mode 100644 index 00000000000..78e5e3d4595 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGhostPairCallback.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btGhostPairCallback interfaces and forwards adding and removal of overlapping pairs from the btBroadphaseInterface to btGhostObject. */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGhostPairCallback extends btOverlappingPairCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGhostPairCallback(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGhostPairCallback(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btGhostPairCallback position(long position) { + return (btGhostPairCallback)super.position(position); + } + @Override public btGhostPairCallback getPointer(long i) { + return new btGhostPairCallback((Pointer)this).offsetAddress(i); + } + + public btGhostPairCallback() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native btBroadphasePair addOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); + + public native Pointer removeOverlappingPair(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1, btDispatcher dispatcher); + + public native void removeOverlappingPairsContainingProxy(btBroadphaseProxy arg0, btDispatcher arg1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkCollisionDescription.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkCollisionDescription.java new file mode 100644 index 00000000000..f56c98effc7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btGjkCollisionDescription.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btGjkCollisionDescription extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btGjkCollisionDescription(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btGjkCollisionDescription(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btGjkCollisionDescription position(long position) { + return (btGjkCollisionDescription)super.position(position); + } + @Override public btGjkCollisionDescription getPointer(long i) { + return new btGjkCollisionDescription((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_firstDir(); public native btGjkCollisionDescription m_firstDir(btVector3 setter); + public native int m_maxGjkIterations(); public native btGjkCollisionDescription m_maxGjkIterations(int setter); + public native @Cast("btScalar") float m_maximumDistanceSquared(); public native btGjkCollisionDescription m_maximumDistanceSquared(float setter); + public native @Cast("btScalar") float m_gjkRelError2(); public native btGjkCollisionDescription m_gjkRelError2(float setter); + public btGjkCollisionDescription() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java index 8859bbd113f..c2fa457103a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedOverlappingPairCache.java @@ -52,9 +52,7 @@ public class btHashedOverlappingPairCache extends btOverlappingPairCache { public native btBroadphasePair getOverlappingPairArrayPtr(); - - - + public native @Cast("btBroadphasePairArray*") @ByRef BT_QUANTIZED_BVH_NODE_Array getOverlappingPairArray(); public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedSimplePairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedSimplePairCache.java new file mode 100644 index 00000000000..e278c07dc50 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHashedSimplePairCache.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// #ifdef BT_DEBUG_COLLISION_PAIRS +// #endif //BT_DEBUG_COLLISION_PAIRS + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btHashedSimplePairCache extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashedSimplePairCache(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHashedSimplePairCache(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btHashedSimplePairCache position(long position) { + return (btHashedSimplePairCache)super.position(position); + } + @Override public btHashedSimplePairCache getPointer(long i) { + return new btHashedSimplePairCache((Pointer)this).offsetAddress(i); + } + + public btHashedSimplePairCache() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void removeAllPairs(); + + public native Pointer removeOverlappingPair(int indexA, int indexB); + + // Add a pair and return the new pair. If the pair already exists, + // no new pair is created and the old one is returned. + public native btSimplePair addOverlappingPair(int indexA, int indexB); + + public native btSimplePair getOverlappingPairArrayPtr(); + + public native @Cast("btSimplePairArray*") @ByRef BT_QUANTIZED_BVH_NODE_Array getOverlappingPairArray(); + + public native btSimplePair findPair(int indexA, int indexB); + + public native int GetCount(); + + public native int getNumOverlappingPairs(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHingeConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHingeConstraint.java new file mode 100644 index 00000000000..e3f829742f0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btHingeConstraint.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btHingeConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btHingeConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHingeConstraint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMaterial.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMaterial.java new file mode 100644 index 00000000000..ccbd0b216ba --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMaterial.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +// Material class to be used by btMultimaterialTriangleMeshShape to store triangle properties +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMaterial extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMaterial(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMaterial(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMaterial position(long position) { + return (btMaterial)super.position(position); + } + @Override public btMaterial getPointer(long i) { + return new btMaterial((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_friction(); public native btMaterial m_friction(float setter); + public native @Cast("btScalar") float m_restitution(); public native btMaterial m_restitution(float setter); + public native int pad(int i); public native btMaterial pad(int i, int setter); + @MemberGetter public native IntPointer pad(); + + public btMaterial() { super((Pointer)null); allocate(); } + private native void allocate(); + public btMaterial(@Cast("btScalar") float fric, @Cast("btScalar") float rest) { super((Pointer)null); allocate(fric, rest); } + private native void allocate(@Cast("btScalar") float fric, @Cast("btScalar") float rest); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMaterialProperties.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMaterialProperties.java new file mode 100644 index 00000000000..feb367c4214 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMaterialProperties.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMaterialProperties extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMaterialProperties() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMaterialProperties(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMaterialProperties(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMaterialProperties position(long position) { + return (btMaterialProperties)super.position(position); + } + @Override public btMaterialProperties getPointer(long i) { + return new btMaterialProperties((Pointer)this).offsetAddress(i); + } + + /**m_materialBase ==========> 2 btScalar values make up one material, friction then restitution */ + public native int m_numMaterials(); public native btMaterialProperties m_numMaterials(int setter); + public native @Cast("const unsigned char*") BytePointer m_materialBase(); public native btMaterialProperties m_materialBase(BytePointer setter); + public native int m_materialStride(); public native btMaterialProperties m_materialStride(int setter); + public native @Cast("PHY_ScalarType") int m_materialType(); public native btMaterialProperties m_materialType(int setter); + /**m_numTriangles <=========== This exists in the btIndexedMesh object for the same subpart, but since we're + * padding the structure, it can be reproduced at no real cost + * m_triangleMaterials =====> 1 integer value makes up one entry + * eg: m_triangleMaterials[1] = 5; // This will set triangle 2 to use material 5 */ + public native int m_numTriangles(); public native btMaterialProperties m_numTriangles(int setter); + public native @Cast("const unsigned char*") BytePointer m_triangleMaterialsBase(); public native btMaterialProperties m_triangleMaterialsBase(BytePointer setter); + public native int m_triangleMaterialStride(); public native btMaterialProperties m_triangleMaterialStride(int setter); + /**m_triangleType <========== Automatically set in addMaterialProperties */ + public native @Cast("PHY_ScalarType") int m_triangleType(); public native btMaterialProperties m_triangleType(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMiniSDF.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMiniSDF.java new file mode 100644 index 00000000000..3907165a5c8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMiniSDF.java @@ -0,0 +1,63 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMiniSDF extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMiniSDF(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMiniSDF(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMiniSDF position(long position) { + return (btMiniSDF)super.position(position); + } + @Override public btMiniSDF getPointer(long i) { + return new btMiniSDF((Pointer)this).offsetAddress(i); + } + + public native @ByRef btAlignedBox3d m_domain(); public native btMiniSDF m_domain(btAlignedBox3d setter); + public native @Cast("unsigned int") int m_resolution(int i); public native btMiniSDF m_resolution(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer m_resolution(); + public native @ByRef btVector3 m_cell_size(); public native btMiniSDF m_cell_size(btVector3 setter); + public native @ByRef btVector3 m_inv_cell_size(); public native btMiniSDF m_inv_cell_size(btVector3 setter); + public native @Cast("std::size_t") long m_n_cells(); public native btMiniSDF m_n_cells(long setter); + public native @Cast("std::size_t") long m_n_fields(); public native btMiniSDF m_n_fields(long setter); + public native @Cast("bool") boolean m_isValid(); public native btMiniSDF m_isValid(boolean setter); + + public native @ByRef btDoubleArrayArray m_nodes(); public native btMiniSDF m_nodes(btDoubleArrayArray setter); + public native @ByRef btCell32ArrayArray m_cells(); public native btMiniSDF m_cells(btCell32ArrayArray setter); + public native @ByRef btUnsignedIntArrayArray m_cell_map(); public native btMiniSDF m_cell_map(btUnsignedIntArrayArray setter); + + public btMiniSDF() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("bool") boolean load(@Cast("const char*") BytePointer data, int size); + public native @Cast("bool") boolean load(String data, int size); + public native @Cast("bool") boolean isValid(); + public native @Cast("unsigned int") int multiToSingleIndex(@Const @ByRef btMultiIndex ijk); + + public native @ByVal btAlignedBox3d subdomain(@Const @ByRef btMultiIndex ijk); + + public native @ByVal btMultiIndex singleToMultiIndex(@Cast("unsigned int") int l); + + public native @ByVal btAlignedBox3d subdomain(@Cast("unsigned int") int l); + + public native @ByVal btShapeMatrix shape_function_(@Const @ByRef btVector3 xi, btShapeGradients gradient/*=0*/); + public native @ByVal btShapeMatrix shape_function_(@Const @ByRef btVector3 xi); + + public native @Cast("bool") boolean interpolate(@Cast("unsigned int") int field_id, @ByRef DoublePointer dist, @Const @ByRef btVector3 x, btVector3 gradient); + public native @Cast("bool") boolean interpolate(@Cast("unsigned int") int field_id, @ByRef DoubleBuffer dist, @Const @ByRef btVector3 x, btVector3 gradient); + public native @Cast("bool") boolean interpolate(@Cast("unsigned int") int field_id, @ByRef double[] dist, @Const @ByRef btVector3 x, btVector3 gradient); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiSumShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiSumShape.java index 2497f0cfd94..9bef2aa6b69 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiSumShape.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMinkowskiSumShape.java @@ -11,11 +11,35 @@ import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.BulletCollision.*; + // for the types -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btMinkowskiSumShape extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btMinkowskiSumShape() { super((Pointer)null); } +/** The btMinkowskiSumShape is only for advanced users. This shape represents implicit based minkowski sum of two convex implicit shapes. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMinkowskiSumShape extends btConvexInternalShape { + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btMinkowskiSumShape(Pointer p) { super(p); } + + + public btMinkowskiSumShape(@Const btConvexShape shapeA, @Const btConvexShape shapeB) { super((Pointer)null); allocate(shapeA, shapeB); } + private native void allocate(@Const btConvexShape shapeA, @Const btConvexShape shapeB); + + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void setTransformA(@Const @ByRef btTransform transA); + public native void setTransformB(@Const @ByRef btTransform transB); + + public native @Const @ByRef btTransform getTransformA(); + public native @Const @ByRef btTransform GetTransformB(); + + public native @Cast("btScalar") float getMargin(); + + public native @Const btConvexShape getShapeA(); + public native @Const btConvexShape getShapeB(); + + public native @Cast("const char*") BytePointer getName(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiIndex.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiIndex.java new file mode 100644 index 00000000000..25d0823c514 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultiIndex.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMultiIndex extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btMultiIndex() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiIndex(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiIndex(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btMultiIndex position(long position) { + return (btMultiIndex)super.position(position); + } + @Override public btMultiIndex getPointer(long i) { + return new btMultiIndex((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int ijk(int i); public native btMultiIndex ijk(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer ijk(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultimaterialTriangleMeshShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultimaterialTriangleMeshShape.java new file mode 100644 index 00000000000..f08dd28ae03 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btMultimaterialTriangleMeshShape.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The BvhTriangleMaterialMeshShape extends the btBvhTriangleMeshShape. Its main contribution is the interface into a material array, which allows per-triangle friction and restitution. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btMultimaterialTriangleMeshShape extends btBvhTriangleMeshShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultimaterialTriangleMeshShape(Pointer p) { super(p); } + + + public btMultimaterialTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Cast("bool") boolean buildBvh/*=true*/) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, buildBvh); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Cast("bool") boolean buildBvh/*=true*/); + public btMultimaterialTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression); + + /**optionally pass in a larger bvh aabb, used for quantization. This allows for deformations within this aabb */ + public btMultimaterialTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("bool") boolean buildBvh/*=true*/) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax, buildBvh); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax, @Cast("bool") boolean buildBvh/*=true*/); + public btMultimaterialTriangleMeshShape(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax) { super((Pointer)null); allocate(meshInterface, useQuantizedAabbCompression, bvhAabbMin, bvhAabbMax); } + private native void allocate(btStridingMeshInterface meshInterface, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef btVector3 bvhAabbMin, @Const @ByRef btVector3 bvhAabbMax); + //debugging + public native @Cast("const char*") BytePointer getName(); + + /**Obtains the material for a specific triangle */ + public native @Const btMaterial getMaterialProperties(int partID, int triIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java index abeab943a01..15ca721e29c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btNullPairCache.java @@ -33,7 +33,7 @@ public class btNullPairCache extends btOverlappingPairCache { } public native btBroadphasePair getOverlappingPairArrayPtr(); - + public native @Cast("btBroadphasePairArray*") @ByRef BT_QUANTIZED_BVH_NODE_Array getOverlappingPairArray(); public native void cleanOverlappingPair(@ByRef btBroadphasePair arg0, btDispatcher arg1); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java index ed3f78483bc..ab7884a21be 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btOverlappingPairCache.java @@ -24,7 +24,7 @@ public class btOverlappingPairCache extends btOverlappingPairCallback { public native btBroadphasePair getOverlappingPairArrayPtr(); - + public native @Cast("btBroadphasePairArray*") @ByRef BT_QUANTIZED_BVH_NODE_Array getOverlappingPairArray(); public native void cleanOverlappingPair(@ByRef btBroadphasePair pair, btDispatcher dispatcher); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairCachingGhostObject.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairCachingGhostObject.java new file mode 100644 index 00000000000..025746a9b8e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairCachingGhostObject.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPairCachingGhostObject extends btGhostObject { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPairCachingGhostObject(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPairCachingGhostObject(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btPairCachingGhostObject position(long position) { + return (btPairCachingGhostObject)super.position(position); + } + @Override public btPairCachingGhostObject getPointer(long i) { + return new btPairCachingGhostObject((Pointer)this).offsetAddress(i); + } + + public btPairCachingGhostObject() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**this method is mainly for expert/internal use only. */ + public native void addOverlappingObjectInternal(btBroadphaseProxy otherProxy, btBroadphaseProxy thisProxy/*=0*/); + public native void addOverlappingObjectInternal(btBroadphaseProxy otherProxy); + + public native void removeOverlappingObjectInternal(btBroadphaseProxy otherProxy, btDispatcher dispatcher, btBroadphaseProxy thisProxy/*=0*/); + public native void removeOverlappingObjectInternal(btBroadphaseProxy otherProxy, btDispatcher dispatcher); + + public native btHashedOverlappingPairCache getOverlappingPairCache(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairSet.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairSet.java new file mode 100644 index 00000000000..afb50e285de --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairSet.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** A pairset array */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPairSet extends GIM_PAIR_Array { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPairSet(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPairSet(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btPairSet position(long position) { + return (btPairSet)super.position(position); + } + @Override public btPairSet getPointer(long i) { + return new btPairSet((Pointer)this).offsetAddress(i); + } + + public btPairSet() { super((Pointer)null); allocate(); } + private native void allocate(); + public native void push_pair(int index1, int index2); + + public native void push_pair_inv(int index1, int index2); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoint2PointConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoint2PointConstraint.java new file mode 100644 index 00000000000..c8f56583c9b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPoint2PointConstraint.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPoint2PointConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btPoint2PointConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPoint2PointConstraint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPointCollector.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPointCollector.java new file mode 100644 index 00000000000..730abf4c211 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPointCollector.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPointCollector extends btDiscreteCollisionDetectorInterface.Result { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPointCollector(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPointCollector(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btPointCollector position(long position) { + return (btPointCollector)super.position(position); + } + @Override public btPointCollector getPointer(long i) { + return new btPointCollector((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_normalOnBInWorld(); public native btPointCollector m_normalOnBInWorld(btVector3 setter); + public native @ByRef btVector3 m_pointInWorld(); public native btPointCollector m_pointInWorld(btVector3 setter); + public native @Cast("btScalar") float m_distance(); public native btPointCollector m_distance(float setter); //negative means penetration + + public native @Cast("bool") boolean m_hasResult(); public native btPointCollector m_hasResult(boolean setter); + + public btPointCollector() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void setShapeIdentifiersA(int partId0, int index0); + public native void setShapeIdentifiersB(int partId1, int index1); + + public native void addContactPoint(@Const @ByRef btVector3 normalOnBInWorld, @Const @ByRef btVector3 pointInWorld, @Cast("btScalar") float depth); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPrimitiveManagerBase.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPrimitiveManagerBase.java new file mode 100644 index 00000000000..4761b6d0424 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPrimitiveManagerBase.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Prototype Base class for primitive classification +/** +This class is a wrapper for primitive collections. +This tells relevant info for the Bounding Box set classes, which take care of space classification. +This class can manage Compound shapes and trimeshes, and if it is managing trimesh then the Hierarchy Bounding Box classes will take advantage of primitive Vs Box overlapping tests for getting optimal results and less Per Box compairisons. +*/ +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPrimitiveManagerBase extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPrimitiveManagerBase(Pointer p) { super(p); } + + + /** determines if this manager consist on only triangles, which special case will be optimized */ + public native @Cast("bool") boolean is_trimesh(); + public native int get_primitive_count(); + /** retrieves only the points of the triangle, and the collision margin */ + public native void get_primitive_triangle(int prim_index, @ByRef btPrimitiveTriangle triangle); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPrimitiveTriangle.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPrimitiveTriangle.java new file mode 100644 index 00000000000..101a12d00d5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPrimitiveTriangle.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btPrimitiveTriangle extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btPrimitiveTriangle(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btPrimitiveTriangle(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btPrimitiveTriangle position(long position) { + return (btPrimitiveTriangle)super.position(position); + } + @Override public btPrimitiveTriangle getPointer(long i) { + return new btPrimitiveTriangle((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_vertices(int i); public native btPrimitiveTriangle m_vertices(int i, btVector3 setter); + @MemberGetter public native btVector3 m_vertices(); + public native @ByRef btVector4 m_plane(); public native btPrimitiveTriangle m_plane(btVector4 setter); + public native @Cast("btScalar") float m_margin(); public native btPrimitiveTriangle m_margin(float setter); + public native @Cast("btScalar") float m_dummy(); public native btPrimitiveTriangle m_dummy(float setter); + public btPrimitiveTriangle() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void buildTriPlane(); + + /** Test if triangles could collide */ + public native @Cast("bool") boolean overlap_test_conservative(@Const @ByRef btPrimitiveTriangle other); + + /** Calcs the plane which is paralele to the edge and perpendicular to the triangle plane + /** + \pre this triangle must have its plane calculated. + */ + public native void get_edge_plane(int edge_index, @ByRef btVector4 plane); + + public native void applyTransform(@Const @ByRef btTransform t); + + /** Clips the triangle against this + /** + \pre clipped_points must have MAX_TRI_CLIPPING size, and this triangle must have its plane calculated. + @return the number of clipped points + */ + public native int clip_triangle(@ByRef btPrimitiveTriangle other, btVector3 clipped_points); + + /** Find collision using the clipping method + /** + \pre this triangle and other must have their triangles calculated + */ + public native @Cast("bool") boolean find_triangle_collision_clip_method(@ByRef btPrimitiveTriangle other, @ByRef GIM_TRIANGLE_CONTACT contacts); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhTree.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhTree.java new file mode 100644 index 00000000000..903f26e6bb0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btQuantizedBvhTree.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** Basic Box tree structure */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btQuantizedBvhTree extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btQuantizedBvhTree(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btQuantizedBvhTree(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btQuantizedBvhTree position(long position) { + return (btQuantizedBvhTree)super.position(position); + } + @Override public btQuantizedBvhTree getPointer(long i) { + return new btQuantizedBvhTree((Pointer)this).offsetAddress(i); + } + + public btQuantizedBvhTree() { super((Pointer)null); allocate(); } + private native void allocate(); + + /** prototype functions for box tree management + * \{ */ + public native void build_tree(@ByRef GIM_BVH_DATA_ARRAY primitive_boxes); + + public native void quantizePoint( + @Cast("unsigned short*") ShortPointer quantizedpoint, @Const @ByRef btVector3 point); + public native void quantizePoint( + @Cast("unsigned short*") ShortBuffer quantizedpoint, @Const @ByRef btVector3 point); + public native void quantizePoint( + @Cast("unsigned short*") short[] quantizedpoint, @Const @ByRef btVector3 point); + + public native @Cast("bool") boolean testQuantizedBoxOverlapp( + int node_index, + @Cast("unsigned short*") ShortPointer quantizedMin, @Cast("unsigned short*") ShortPointer quantizedMax); + public native @Cast("bool") boolean testQuantizedBoxOverlapp( + int node_index, + @Cast("unsigned short*") ShortBuffer quantizedMin, @Cast("unsigned short*") ShortBuffer quantizedMax); + public native @Cast("bool") boolean testQuantizedBoxOverlapp( + int node_index, + @Cast("unsigned short*") short[] quantizedMin, @Cast("unsigned short*") short[] quantizedMax); + + public native void clearNodes(); + + /** node count */ + public native int getNodeCount(); + + /** tells if the node is a leaf */ + public native @Cast("bool") boolean isLeafNode(int nodeindex); + + public native int getNodeData(int nodeindex); + + public native int getLeftNode(int nodeindex); + + public native int getRightNode(int nodeindex); + + public native int getEscapeNodeIndex(int nodeindex); + + public native @Const BT_QUANTIZED_BVH_NODE get_node_pointer(int index/*=0*/); + public native @Const BT_QUANTIZED_BVH_NODE get_node_pointer(); + + /**\} */ +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeGradients.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeGradients.java new file mode 100644 index 00000000000..755e4f0e957 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeGradients.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btShapeGradients extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btShapeGradients() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btShapeGradients(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btShapeGradients(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btShapeGradients position(long position) { + return (btShapeGradients)super.position(position); + } + @Override public btShapeGradients getPointer(long i) { + return new btShapeGradients((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_vec(int i); public native btShapeGradients m_vec(int i, btVector3 setter); + @MemberGetter public native btVector3 m_vec(); + + public native void topRowsDivide(int row, double denom); + + public native void bottomRowsMul(int row, double val); + + public native @Cast("btScalar*") @ByRef @Name("operator ()") FloatPointer apply(int i, int j); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeMatrix.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeMatrix.java new file mode 100644 index 00000000000..ce20a5bd16e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapeMatrix.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btShapeMatrix extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btShapeMatrix() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btShapeMatrix(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btShapeMatrix(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btShapeMatrix position(long position) { + return (btShapeMatrix)super.position(position); + } + @Override public btShapeMatrix getPointer(long i) { + return new btShapeMatrix((Pointer)this).offsetAddress(i); + } + + public native double m_vec(int i); public native btShapeMatrix m_vec(int i, double setter); + @MemberGetter public native DoublePointer m_vec(); + + public native @ByRef @Name("operator []") DoublePointer get(int i); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapePairCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapePairCallback.java new file mode 100644 index 00000000000..bde2832d012 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btShapePairCallback.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btShapePairCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btShapePairCallback(Pointer p) { super(p); } + protected btShapePairCallback() { allocate(); } + private native void allocate(); + public native @Cast("bool") boolean call(@Const btCollisionShape pShape0, @Const btCollisionShape pShape1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplePair.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplePair.java new file mode 100644 index 00000000000..a7e05971bf2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSimplePair.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSimplePair extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSimplePair(Pointer p) { super(p); } + + public btSimplePair(int indexA, int indexB) { super((Pointer)null); allocate(indexA, indexB); } + private native void allocate(int indexA, int indexB); + + public native int m_indexA(); public native btSimplePair m_indexA(int setter); + public native int m_indexB(); public native btSimplePair m_indexB(int setter); + public native Pointer m_userPointer(); public native btSimplePair m_userPointer(Pointer setter); + public native int m_userValue(); public native btSimplePair m_userValue(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSliderConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSliderConstraint.java new file mode 100644 index 00000000000..b539eaf6aca --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSliderConstraint.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSliderConstraint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSliderConstraint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSliderConstraint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java index 9d2f5ca1a6a..9a2c7bdc0dd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSortedOverlappingPairCache.java @@ -49,9 +49,7 @@ public class btSortedOverlappingPairCache extends btOverlappingPairCache { public native @Cast("bool") boolean needsBroadphaseCollision(btBroadphaseProxy proxy0, btBroadphaseProxy proxy1); - - - + public native @Cast("btBroadphasePairArray*") @ByRef BT_QUANTIZED_BVH_NODE_Array getOverlappingPairArray(); public native btBroadphasePair getOverlappingPairArrayPtr(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereBoxCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereBoxCollisionAlgorithm.java new file mode 100644 index 00000000000..1fa72b10d1a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereBoxCollisionAlgorithm.java @@ -0,0 +1,58 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btSphereBoxCollisionAlgorithm provides sphere-box collision detection. + * Other features are frame-coherency (persistent data) and collision response. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSphereBoxCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSphereBoxCollisionAlgorithm(Pointer p) { super(p); } + + public btSphereBoxCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped) { super((Pointer)null); allocate(mf, ci, body0Wrap, body1Wrap, isSwapped); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public native @Cast("bool") boolean getSphereDistance(@Const btCollisionObjectWrapper boxObjWrap, @ByRef btVector3 v3PointOnBox, @ByRef btVector3 normal, @Cast("btScalar*") @ByRef FloatPointer penetrationDepth, @Const @ByRef btVector3 v3SphereCenter, @Cast("btScalar") float fRadius, @Cast("btScalar") float maxContactDistance); + public native @Cast("bool") boolean getSphereDistance(@Const btCollisionObjectWrapper boxObjWrap, @ByRef btVector3 v3PointOnBox, @ByRef btVector3 normal, @Cast("btScalar*") @ByRef FloatBuffer penetrationDepth, @Const @ByRef btVector3 v3SphereCenter, @Cast("btScalar") float fRadius, @Cast("btScalar") float maxContactDistance); + public native @Cast("bool") boolean getSphereDistance(@Const btCollisionObjectWrapper boxObjWrap, @ByRef btVector3 v3PointOnBox, @ByRef btVector3 normal, @Cast("btScalar*") @ByRef float[] penetrationDepth, @Const @ByRef btVector3 v3SphereCenter, @Cast("btScalar") float fRadius, @Cast("btScalar") float maxContactDistance); + + public native @Cast("btScalar") float getSpherePenetration(@Const @ByRef btVector3 boxHalfExtent, @Const @ByRef btVector3 sphereRelPos, @ByRef btVector3 closestPoint, @ByRef btVector3 normal); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java index ed5b28a26df..eeab2a5b619 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereSphereCollisionAlgorithm.java @@ -32,7 +32,7 @@ public class btSphereSphereCollisionAlgorithm extends btActivatingCollisionAlgor public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); - + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); public static class CreateFunc extends btCollisionAlgorithmCreateFunc { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereTriangleCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereTriangleCollisionAlgorithm.java new file mode 100644 index 00000000000..e190f12928f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btSphereTriangleCollisionAlgorithm.java @@ -0,0 +1,56 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/** btSphereSphereCollisionAlgorithm provides sphere-sphere collision detection. + * Other features are frame-coherency (persistent data) and collision response. + * Also provides the most basic sample for custom/user btCollisionAlgorithm */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btSphereTriangleCollisionAlgorithm extends btActivatingCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSphereTriangleCollisionAlgorithm(Pointer p) { super(p); } + + public btSphereTriangleCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean swapped) { super((Pointer)null); allocate(mf, ci, body0Wrap, body1Wrap, swapped); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean swapped); + + public btSphereTriangleCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangle.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangle.java new file mode 100644 index 00000000000..cc7ddfa5b63 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangle.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) +public class btTriangle extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btTriangle() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTriangle(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriangle(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btTriangle position(long position) { + return (btTriangle)super.position(position); + } + @Override public btTriangle getPointer(long i) { + return new btTriangle((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3 m_vertex0(); public native btTriangle m_vertex0(btVector3 setter); + public native @ByRef btVector3 m_vertex1(); public native btTriangle m_vertex1(btVector3 setter); + public native @ByRef btVector3 m_vertex2(); public native btTriangle m_vertex2(btVector3 setter); + public native int m_partId(); public native btTriangle m_partId(int setter); + public native int m_triangleIndex(); public native btTriangle m_triangleIndex(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleBuffer.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleBuffer.java new file mode 100644 index 00000000000..07929ba2cb2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btTriangleBuffer.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletCollision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; + +import static org.bytedeco.bullet.global.BulletCollision.*; + + +/**The btTriangleBuffer callback can be useful to collect and store overlapping triangles between AABB and concave objects that support 'processAllTriangles' + * Example usage of this class: + * btTriangleBuffer triBuf; + * concaveShape->processAllTriangles(&triBuf,aabbMin, aabbMax); + * for (int i=0;i >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btDoubleArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDoubleArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDoubleArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDoubleArrayArray position(long position) { + return (btDoubleArrayArray)super.position(position); + } + @Override public btDoubleArrayArray getPointer(long i) { + return new btDoubleArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDoubleArrayArray put(@Const @ByRef btDoubleArrayArray other); + public btDoubleArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDoubleArrayArray(@Const @ByRef btDoubleArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDoubleArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDoubleArray at(int n); + + public native @ByRef @Name("operator []") btDoubleArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btDoubleArray fillData); + public native void resize(int newsize); + public native @ByRef btDoubleArray expandNonInitializing(); + + public native @ByRef btDoubleArray expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btDoubleArray fillValue); + public native @ByRef btDoubleArray expand(); + + public native void push_back(@Const @ByRef btDoubleArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDoubleArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btUnsignedIntArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btUnsignedIntArrayArray.java new file mode 100644 index 00000000000..4db105226b9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btUnsignedIntArrayArray.java @@ -0,0 +1,86 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btAlignedObjectArray >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btUnsignedIntArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btUnsignedIntArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btUnsignedIntArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btUnsignedIntArrayArray position(long position) { + return (btUnsignedIntArrayArray)super.position(position); + } + @Override public btUnsignedIntArrayArray getPointer(long i) { + return new btUnsignedIntArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btUnsignedIntArrayArray put(@Const @ByRef btUnsignedIntArrayArray other); + public btUnsignedIntArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btUnsignedIntArrayArray(@Const @ByRef btUnsignedIntArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btUnsignedIntArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btUIntArray at(int n); + + public native @ByRef @Name("operator []") btUIntArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btUIntArray fillData); + public native void resize(int newsize); + public native @ByRef btUIntArray expandNonInitializing(); + + public native @ByRef btUIntArray expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btUIntArray fillValue); + public native @ByRef btUIntArray expand(); + + public native void push_back(@Const @ByRef btUIntArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btUnsignedIntArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index 7df9509b723..f16a1cc29a4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -55,12 +55,42 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #ifdef BT_USE_PLACEMENT_NEW // #include +// Targeting ../BulletCollision/BT_QUANTIZED_BVH_NODE_Array.java + + +// Targeting ../BulletCollision/GIM_BVH_DATA_Array.java + + +// Targeting ../BulletCollision/GIM_BVH_TREE_NODE_Array.java + + +// Targeting ../BulletCollision/GIM_CONTACT_Array.java + + +// Targeting ../BulletCollision/GIM_PAIR_Array.java + + +// Targeting ../BulletCollision/btCell32ArrayArray.java + + // Targeting ../BulletCollision/btBvhSubtreeInfoArray.java +// Targeting ../BulletCollision/btCell32Array.java + + // Targeting ../BulletCollision/btCollisionObjectArray.java +// Targeting ../BulletCollision/btDbvtStkNNArray.java + + +// Targeting ../BulletCollision/btDbvtStkNPSArray.java + + +// Targeting ../BulletCollision/btFaceArray.java + + // Targeting ../BulletCollision/btIndexedMeshArray.java @@ -266,9 +296,6 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // #include "LinearMath/btScalar.h" // #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btCollisionObjectWrapper.java - - // Targeting ../BulletCollision/btCollisionAlgorithmConstructionInfo.java @@ -547,13 +574,9 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, public static final int DBVT_BP_ENABLE_BENCHMARK = 0; //#define DBVT_BP_MARGIN (btScalar)0.05 public static native @Cast("btScalar") float gDbvtMargin(); public static native void gDbvtMargin(float setter); +// Targeting ../BulletCollision/btDbvtProxy.java -// #if DBVT_BP_PROFILE -// #endif -// -// btDbvtProxy -// // Targeting ../BulletCollision/btDbvtBroadphase.java @@ -795,6 +818,34 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, // #endif //BT_SIMPLE_BROADPHASE_H +// Parsed from BulletCollision/NarrowPhaseCollision/btComputeGjkEpaPenetration.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H +// #define BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H + +// #include "LinearMath/btTransform.h" // Note that btVector3 might be double precision... +// #include "btGjkEpa3.h" +// #include "btGjkCollisionDescription.h" +// #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" + +// #endif //BT_GJK_EPA_PENETATION_CONVEX_COLLISION_H + + // Parsed from BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h /* @@ -847,9 +898,6 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, // #include "LinearMath/btTransform.h" // #include "LinearMath/btVector3.h" // #include "LinearMath/btScalar.h" -// Targeting ../BulletCollision/btMinkowskiSumShape.java - - // #include "LinearMath/btIDebugDraw.h" // #ifdef BT_USE_DOUBLE_PRECISION @@ -922,6 +970,34 @@ public static native void Merge(@Const @ByRef btDbvtAabbMm a, // #endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H +// Parsed from BulletCollision/NarrowPhaseCollision/btGjkCollisionDescription.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef GJK_COLLISION_DESCRIPTION_H +// #define GJK_COLLISION_DESCRIPTION_H + +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btGjkCollisionDescription.java + + + +// #endif //GJK_COLLISION_DESCRIPTION_H + + // Parsed from BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h /* @@ -1455,6 +1531,34 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_PERSISTENT_MANIFOLD_H +// Parsed from BulletCollision/NarrowPhaseCollision/btPointCollector.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_POINT_COLLECTOR_H +// #define BT_POINT_COLLECTOR_H + +// #include "btDiscreteCollisionDetectorInterface.h" +// Targeting ../BulletCollision/btPointCollector.java + + + +// #endif //BT_POINT_COLLECTOR_H + + // Parsed from BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h /* @@ -1680,6 +1784,67 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H +// Parsed from BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_BOX_BOX__COLLISION_ALGORITHM_H +// #define BT_BOX_BOX__COLLISION_ALGORITHM_H + +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// Targeting ../BulletCollision/btBoxBoxCollisionAlgorithm.java + + + +// #endif //BT_BOX_BOX__COLLISION_ALGORITHM_H + + +// Parsed from BulletCollision/CollisionDispatch/btBoxBoxDetector.h + +/* + * Box-Box collision detection re-distributed under the ZLib license with permission from Russell L. Smith + * Original version is from Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith. + * All rights reserved. Email: russ@q12.org Web: www.q12.org + +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_BOX_BOX_DETECTOR_H +// #define BT_BOX_BOX_DETECTOR_H +// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" +// Targeting ../BulletCollision/btBoxBoxDetector.java + + + +// #endif //BT_BOX_BOX_DETECTOR_H + + // Parsed from BulletCollision/CollisionDispatch/btCollisionConfiguration.h /* @@ -1856,6 +2021,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_COLLISION_OBJECT_H +// Parsed from BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h + +// #ifndef BT_COLLISION_OBJECT_WRAPPER_H +// #define BT_COLLISION_OBJECT_WRAPPER_H + +/**btCollisionObjectWrapperis an internal data structure. + * Most users can ignore this and use btCollisionObject and btCollisionShape instead */ +// #include "LinearMath/btScalar.h" // for SIMD_FORCE_INLINE definition + +// #define BT_DECLARE_STACK_ONLY_OBJECT +// private: +// void* operator new(size_t size); +// void operator delete(void*); +// Targeting ../BulletCollision/btCollisionObjectWrapper.java + + + +// #endif //BT_COLLISION_OBJECT_WRAPPER_H + + // Parsed from BulletCollision/CollisionDispatch/btCollisionWorld.h /* @@ -1942,16 +2127,16 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //BT_COLLISION_WORLD_H -// Parsed from BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h +// Parsed from BulletCollision/CollisionDispatch/btCollisionWorldImporter.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2014 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -1959,25 +2144,45 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H -// #define BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H +// #ifndef BT_COLLISION_WORLD_IMPORTER_H +// #define BT_COLLISION_WORLD_IMPORTER_H -// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" -// #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" -// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" -// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" -// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" -// #include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil -// Targeting ../BulletCollision/btConvex2dConvex2dAlgorithm.java +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btHashMap.h" +// Targeting ../BulletCollision/ConstraintInput.java +// Targeting ../BulletCollision/btPoint2PointConstraint.java -// #endif //BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H +// Targeting ../BulletCollision/btHingeConstraint.java -// Parsed from BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h + +// Targeting ../BulletCollision/btConeTwistConstraint.java + + +// Targeting ../BulletCollision/btGeneric6DofConstraint.java + + +// Targeting ../BulletCollision/btGeneric6DofSpringConstraint.java + + +// Targeting ../BulletCollision/btSliderConstraint.java + + +// Targeting ../BulletCollision/btGearConstraint.java + + +// Targeting ../BulletCollision/btCollisionWorldImporter.java + + + +// #endif //BT_WORLD_IMPORTER_H + + +// Parsed from BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -1992,27 +2197,37 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. + */ -// #ifndef BT_DEFAULT_COLLISION_CONFIGURATION -// #define BT_DEFAULT_COLLISION_CONFIGURATION +// #ifndef BT_COMPOUND_COLLISION_ALGORITHM_H +// #define BT_COMPOUND_COLLISION_ALGORITHM_H -// #include "btCollisionConfiguration.h" -// Targeting ../BulletCollision/btDefaultCollisionConstructionInfo.java +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" + +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "btCollisionCreateFunc.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletCollision/BroadphaseCollision/btDbvt.h" +// Targeting ../BulletCollision/btShapePairCallback.java -// Targeting ../BulletCollision/btDefaultCollisionConfiguration.java +public static native btShapePairCallback gCompoundChildShapePairCallback(); public static native void gCompoundChildShapePairCallback(btShapePairCallback setter); +// Targeting ../BulletCollision/btCompoundCollisionAlgorithm.java -// #endif //BT_DEFAULT_COLLISION_CONFIGURATION +// #endif //BT_COMPOUND_COLLISION_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h +// Parsed from BulletCollision/CollisionDispatch/btCompoundCompoundCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2023,63 +2238,68 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. -*/ -// #ifndef BT_EMPTY_ALGORITH -// #define BT_EMPTY_ALGORITH -// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" -// #include "btCollisionCreateFunc.h" -// #include "btCollisionDispatcher.h" +*/ -// #define ATTRIBUTE_ALIGNED(a) -// Targeting ../BulletCollision/btEmptyAlgorithm.java +// #ifndef BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H +// #define BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H +// #include "btCompoundCollisionAlgorithm.h" +// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" -// #endif //BT_EMPTY_ALGORITH +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletCollision/CollisionDispatch/btHashedSimplePairCache.h" +public static native btShapePairCallback gCompoundCompoundChildShapePairCallback(); public static native void gCompoundCompoundChildShapePairCallback(btShapePairCallback setter); +// Targeting ../BulletCollision/btCompoundCompoundCollisionAlgorithm.java -// Parsed from BulletCollision/CollisionDispatch/btInternalEdgeUtility.h -// #ifndef BT_INTERNAL_EDGE_UTILITY_H -// #define BT_INTERNAL_EDGE_UTILITY_H +// #endif //BT_COMPOUND_COMPOUND_COLLISION_ALGORITHM_H -// #include "LinearMath/btHashMap.h" -// #include "LinearMath/btVector3.h" -// #include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" +// Parsed from BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h -/**The btInternalEdgeUtility helps to avoid or reduce artifacts due to wrong collision normals caused by internal edges. - * See also http://code.google.com/p/bullet/issues/detail?id=27 */ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org -/** enum btInternalEdgeAdjustFlags */ -public static final int - BT_TRIANGLE_CONVEX_BACKFACE_MODE = 1, - BT_TRIANGLE_CONCAVE_DOUBLE_SIDED = 2, //double sided options are experimental, single sided is recommended - BT_TRIANGLE_CONVEX_DOUBLE_SIDED = 4; +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: -/**Call btGenerateInternalEdgeInfo to create triangle info, store in the shape 'userInfo' */ -public static native void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape trimeshShape, btTriangleInfoMap triangleInfoMap); +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ -public static native void btGenerateInternalEdgeInfo(btHeightfieldTerrainShape trimeshShape, btTriangleInfoMap triangleInfoMap); +// #ifndef BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H +// #define BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H -/**Call the btFixMeshNormal to adjust the collision normal, using the triangle info map (generated using btGenerateInternalEdgeInfo) - * If this info map is missing, or the triangle is not store in this map, nothing will be done */ -public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags/*=0*/); -public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0); +// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +// #include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil +// Targeting ../BulletCollision/btConvex2dConvex2dAlgorithm.java -/**Enable the BT_INTERNAL_EDGE_DEBUG_DRAW define and call btSetDebugDrawer, to get visual info to see if the internal edge utility works properly. - * If the utility doesn't work properly, you might have to adjust the threshold values in btTriangleInfoMap */ -//#define BT_INTERNAL_EDGE_DEBUG_DRAW -// #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW -// #endif //BT_INTERNAL_EDGE_DEBUG_DRAW -// #endif //BT_INTERNAL_EDGE_UTILITY_H +// #endif //BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btManifoldResult.h +// Parsed from BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -2096,38 +2316,27 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_MANIFOLD_RESULT_H -// #define BT_MANIFOLD_RESULT_H +// #ifndef BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H +// #define BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" +// #include "BulletCollision/CollisionShapes/btTriangleCallback.h" // #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" - -// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" - -// #include "LinearMath/btTransform.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" -// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" -// Targeting ../BulletCollision/ContactAddedCallback.java - - -public static native ContactAddedCallback gContactAddedCallback(); public static native void gContactAddedCallback(ContactAddedCallback setter); -// Targeting ../BulletCollision/CalculateCombinedCallback.java - +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "btCollisionCreateFunc.h" +// Targeting ../BulletCollision/btConvexTriangleCallback.java -public static native CalculateCombinedCallback gCalculateCombinedRestitutionCallback(); public static native void gCalculateCombinedRestitutionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedFrictionCallback(); public static native void gCalculateCombinedFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback(); public static native void gCalculateCombinedRollingFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback(); public static native void gCalculateCombinedSpinningFrictionCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedContactDampingCallback(); public static native void gCalculateCombinedContactDampingCallback(CalculateCombinedCallback setter); -public static native CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback(); public static native void gCalculateCombinedContactStiffnessCallback(CalculateCombinedCallback setter); -// Targeting ../BulletCollision/btManifoldResult.java +// Targeting ../BulletCollision/btConvexConcaveCollisionAlgorithm.java -// #endif //BT_MANIFOLD_RESULT_H +// #endif //BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btSimulationIslandManager.h +// Parsed from BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -2144,21 +2353,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SIMULATION_ISLAND_MANAGER_H -// #define BT_SIMULATION_ISLAND_MANAGER_H +// #ifndef BT_CONVEX_CONVEX_ALGORITHM_H +// #define BT_CONVEX_CONVEX_ALGORITHM_H -// #include "BulletCollision/CollisionDispatch/btUnionFind.h" +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h" // #include "btCollisionCreateFunc.h" -// #include "LinearMath/btAlignedObjectArray.h" -// #include "btCollisionObject.h" -// Targeting ../BulletCollision/btSimulationIslandManager.java +// #include "btCollisionDispatcher.h" +// #include "LinearMath/btTransformUtil.h" //for btConvexSeparatingDistanceUtil +// #include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h" +// Targeting ../BulletCollision/btConvexConvexAlgorithm.java -// #endif //BT_SIMULATION_ISLAND_MANAGER_H +// #endif //BT_CONVEX_CONVEX_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h +// Parsed from BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -2166,8 +2380,8 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -2175,21 +2389,23 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H -// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #ifndef BT_CONVEX_PLANE_COLLISION_ALGORITHM_H +// #define BT_CONVEX_PLANE_COLLISION_ALGORITHM_H -// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" // #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" // #include "btCollisionDispatcher.h" -// Targeting ../BulletCollision/btSphereSphereCollisionAlgorithm.java +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btConvexPlaneCollisionAlgorithm.java -// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #endif //BT_CONVEX_PLANE_COLLISION_ALGORITHM_H -// Parsed from BulletCollision/CollisionDispatch/btUnionFind.h + +// Parsed from BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h /* Bullet Continuous Collision Detection and Physics Library @@ -2206,26 +2422,21 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_UNION_FIND_H -// #define BT_UNION_FIND_H - -// #include "LinearMath/btAlignedObjectArray.h" - -public static final int USE_PATH_COMPRESSION = 1; +// #ifndef BT_DEFAULT_COLLISION_CONFIGURATION +// #define BT_DEFAULT_COLLISION_CONFIGURATION -/**see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406 */ -public static final int STATIC_SIMULATION_ISLAND_OPTIMIZATION = 1; -// Targeting ../BulletCollision/btElement.java +// #include "btCollisionConfiguration.h" +// Targeting ../BulletCollision/btDefaultCollisionConstructionInfo.java -// Targeting ../BulletCollision/btUnionFind.java +// Targeting ../BulletCollision/btDefaultCollisionConfiguration.java -// #endif //BT_UNION_FIND_H +// #endif //BT_DEFAULT_COLLISION_CONFIGURATION -// Parsed from BulletCollision/CollisionShapes/btBox2dShape.h +// Parsed from BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -2242,26 +2453,25 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_OBB_BOX_2D_SHAPE_H -// #define BT_OBB_BOX_2D_SHAPE_H +// #ifndef BT_EMPTY_ALGORITH +// #define BT_EMPTY_ALGORITH +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// #include "btCollisionCreateFunc.h" +// #include "btCollisionDispatcher.h" -// #include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" -// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btMinMax.h" -// Targeting ../BulletCollision/btBox2dShape.java +// #define ATTRIBUTE_ALIGNED(a) +// Targeting ../BulletCollision/btEmptyAlgorithm.java -// #endif //BT_OBB_BOX_2D_SHAPE_H +// #endif //BT_EMPTY_ALGORITH -// Parsed from BulletCollision/CollisionShapes/btBoxShape.h +// Parsed from BulletCollision/CollisionDispatch/btGhostObject.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2274,26 +2484,32 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_OBB_BOX_MINKOWSKI_H -// #define BT_OBB_BOX_MINKOWSKI_H +// #ifndef BT_GHOST_OBJECT_H +// #define BT_GHOST_OBJECT_H -// #include "btPolyhedralConvexShape.h" -// #include "btCollisionMargin.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btMinMax.h" -// Targeting ../BulletCollision/btBoxShape.java +// #include "btCollisionObject.h" +// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCallback.h" +// #include "LinearMath/btAlignedAllocator.h" +// #include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h" +// #include "btCollisionWorld.h" +// Targeting ../BulletCollision/btGhostObject.java +// Targeting ../BulletCollision/btPairCachingGhostObject.java -// #endif //BT_OBB_BOX_MINKOWSKI_H +// Targeting ../BulletCollision/btGhostPairCallback.java + + + +// #endif -// Parsed from BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h + +// Parsed from BulletCollision/CollisionDispatch/btHashedSimplePairCache.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2306,32 +2522,67 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H -// #define BT_BVH_TRIANGLE_MESH_SHAPE_H +// #ifndef BT_HASHED_SIMPLE_PAIR_CACHE_H +// #define BT_HASHED_SIMPLE_PAIR_CACHE_H -// #include "btTriangleMeshShape.h" -// #include "btOptimizedBvh.h" -// #include "LinearMath/btAlignedAllocator.h" -// #include "btTriangleInfoMap.h" -// Targeting ../BulletCollision/btBvhTriangleMeshShape.java +// #include "LinearMath/btAlignedObjectArray.h" +@MemberGetter public static native int BT_SIMPLE_NULL_PAIR(); +// Targeting ../BulletCollision/btSimplePair.java -// Targeting ../BulletCollision/btTriangleMeshShapeData.java +// Targeting ../BulletCollision/btHashedSimplePairCache.java -// clang-format on +// #endif //BT_HASHED_SIMPLE_PAIR_CACHE_H -// #endif //BT_BVH_TRIANGLE_MESH_SHAPE_H +// Parsed from BulletCollision/CollisionDispatch/btInternalEdgeUtility.h -// Parsed from BulletCollision/CollisionShapes/btCapsuleShape.h +// #ifndef BT_INTERNAL_EDGE_UTILITY_H +// #define BT_INTERNAL_EDGE_UTILITY_H + +// #include "LinearMath/btHashMap.h" +// #include "LinearMath/btVector3.h" + +// #include "BulletCollision/CollisionShapes/btTriangleInfoMap.h" + +/**The btInternalEdgeUtility helps to avoid or reduce artifacts due to wrong collision normals caused by internal edges. + * See also http://code.google.com/p/bullet/issues/detail?id=27 */ + +/** enum btInternalEdgeAdjustFlags */ +public static final int + BT_TRIANGLE_CONVEX_BACKFACE_MODE = 1, + BT_TRIANGLE_CONCAVE_DOUBLE_SIDED = 2, //double sided options are experimental, single sided is recommended + BT_TRIANGLE_CONVEX_DOUBLE_SIDED = 4; + +/**Call btGenerateInternalEdgeInfo to create triangle info, store in the shape 'userInfo' */ +public static native void btGenerateInternalEdgeInfo(btBvhTriangleMeshShape trimeshShape, btTriangleInfoMap triangleInfoMap); + +public static native void btGenerateInternalEdgeInfo(btHeightfieldTerrainShape trimeshShape, btTriangleInfoMap triangleInfoMap); + +/**Call the btFixMeshNormal to adjust the collision normal, using the triangle info map (generated using btGenerateInternalEdgeInfo) + * If this info map is missing, or the triangle is not store in this map, nothing will be done */ +public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0, int normalAdjustFlags/*=0*/); +public static native void btAdjustInternalEdgeContacts(@ByRef btManifoldPoint cp, @Const btCollisionObjectWrapper trimeshColObj0Wrap, @Const btCollisionObjectWrapper otherColObj1Wrap, int partId0, int index0); + +/**Enable the BT_INTERNAL_EDGE_DEBUG_DRAW define and call btSetDebugDrawer, to get visual info to see if the internal edge utility works properly. + * If the utility doesn't work properly, you might have to adjust the threshold values in btTriangleInfoMap */ +//#define BT_INTERNAL_EDGE_DEBUG_DRAW + +// #ifdef BT_INTERNAL_EDGE_DEBUG_DRAW +// #endif //BT_INTERNAL_EDGE_DEBUG_DRAW + +// #endif //BT_INTERNAL_EDGE_UTILITY_H + + +// Parsed from BulletCollision/CollisionDispatch/btManifoldResult.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2344,39 +2595,42 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CAPSULE_SHAPE_H -// #define BT_CAPSULE_SHAPE_H - -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btCapsuleShape.java - - -// Targeting ../BulletCollision/btCapsuleShapeX.java - - -// Targeting ../BulletCollision/btCapsuleShapeZ.java +// #ifndef BT_MANIFOLD_RESULT_H +// #define BT_MANIFOLD_RESULT_H +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" -// Targeting ../BulletCollision/btCapsuleShapeData.java +// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" +// #include "LinearMath/btTransform.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +// Targeting ../BulletCollision/ContactAddedCallback.java +public static native ContactAddedCallback gContactAddedCallback(); public static native void gContactAddedCallback(ContactAddedCallback setter); +// Targeting ../BulletCollision/CalculateCombinedCallback.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ +public static native CalculateCombinedCallback gCalculateCombinedRestitutionCallback(); public static native void gCalculateCombinedRestitutionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedFrictionCallback(); public static native void gCalculateCombinedFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedRollingFrictionCallback(); public static native void gCalculateCombinedRollingFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedSpinningFrictionCallback(); public static native void gCalculateCombinedSpinningFrictionCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedContactDampingCallback(); public static native void gCalculateCombinedContactDampingCallback(CalculateCombinedCallback setter); +public static native CalculateCombinedCallback gCalculateCombinedContactStiffnessCallback(); public static native void gCalculateCombinedContactStiffnessCallback(CalculateCombinedCallback setter); +// Targeting ../BulletCollision/btManifoldResult.java -// #endif //BT_CAPSULE_SHAPE_H +// #endif //BT_MANIFOLD_RESULT_H -// Parsed from BulletCollision/CollisionShapes/btCollisionShape.h +// Parsed from BulletCollision/CollisionDispatch/btSimulationIslandManager.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2389,30 +2643,25 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_COLLISION_SHAPE_H -// #define BT_COLLISION_SHAPE_H - -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types -// Targeting ../BulletCollision/btCollisionShape.java - - -// Targeting ../BulletCollision/btCollisionShapeData.java +// #ifndef BT_SIMULATION_ISLAND_MANAGER_H +// #define BT_SIMULATION_ISLAND_MANAGER_H +// #include "BulletCollision/CollisionDispatch/btUnionFind.h" +// #include "btCollisionCreateFunc.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btCollisionObject.h" +// Targeting ../BulletCollision/btSimulationIslandManager.java -// clang-format on -// #endif //BT_COLLISION_SHAPE_H +// #endif //BT_SIMULATION_ISLAND_MANAGER_H -// Parsed from BulletCollision/CollisionShapes/btCompoundShape.h +// Parsed from BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2425,43 +2674,58 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_COMPOUND_SHAPE_H -// #define BT_COMPOUND_SHAPE_H - -// #include "btCollisionShape.h" +// #ifndef BT_SPHERE_BOX_COLLISION_ALGORITHM_H +// #define BT_SPHERE_BOX_COLLISION_ALGORITHM_H -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "btCollisionMargin.h" -// #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btCompoundShapeChild.java +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "btCollisionDispatcher.h" +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btSphereBoxCollisionAlgorithm.java -public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btCompoundShapeChild c1, @Const @ByRef btCompoundShapeChild c2); -// Targeting ../BulletCollision/btCompoundShape.java +// #endif //BT_SPHERE_BOX_COLLISION_ALGORITHM_H -// Targeting ../BulletCollision/btCompoundShapeChildData.java +// Parsed from BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h -// Targeting ../BulletCollision/btCompoundShapeData.java +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H +// #define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H -// clang-format on +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "btCollisionDispatcher.h" +// Targeting ../BulletCollision/btSphereSphereCollisionAlgorithm.java -// #endif //BT_COMPOUND_SHAPE_H +// #endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H -// Parsed from BulletCollision/CollisionShapes/btConcaveShape.h +// Parsed from BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2474,35 +2738,25 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONCAVE_SHAPE_H -// #define BT_CONCAVE_SHAPE_H - -// #include "btCollisionShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "btTriangleCallback.h" +// #ifndef BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H +// #define BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H -/** PHY_ScalarType enumerates possible scalar types. - * See the btStridingMeshInterface or btHeightfieldTerrainShape for its use */ -/** enum PHY_ScalarType */ -public static final int - PHY_FLOAT = 0, - PHY_DOUBLE = 1, - PHY_INTEGER = 2, - PHY_SHORT = 3, - PHY_FIXEDPOINT88 = 4, - PHY_UCHAR = 5; -// Targeting ../BulletCollision/btConcaveShape.java +// #include "btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "btCollisionDispatcher.h" +// Targeting ../BulletCollision/btSphereTriangleCollisionAlgorithm.java -// #endif //BT_CONCAVE_SHAPE_H +// #endif //BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H -// Parsed from BulletCollision/CollisionShapes/btConeShape.h +// Parsed from BulletCollision/CollisionDispatch/btUnionFind.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2515,37 +2769,30 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONE_MINKOWSKI_H -// #define BT_CONE_MINKOWSKI_H - -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btConeShape.java - - -// Targeting ../BulletCollision/btConeShapeX.java - - -// Targeting ../BulletCollision/btConeShapeZ.java - +// #ifndef BT_UNION_FIND_H +// #define BT_UNION_FIND_H -// Targeting ../BulletCollision/btConeShapeData.java +// #include "LinearMath/btAlignedObjectArray.h" +public static final int USE_PATH_COMPRESSION = 1; +/**see for discussion of static island optimizations by Vroonsh here: http://code.google.com/p/bullet/issues/detail?id=406 */ +public static final int STATIC_SIMULATION_ISLAND_OPTIMIZATION = 1; +// Targeting ../BulletCollision/btElement.java +// Targeting ../BulletCollision/btUnionFind.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_CONE_MINKOWSKI_H +// #endif //BT_UNION_FIND_H -// Parsed from BulletCollision/CollisionShapes/btConvex2dShape.h +// Parsed from BulletCollision/CollisionDispatch/SphereTriangleDetector.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2558,23 +2805,21 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_2D_SHAPE_H -// #define BT_CONVEX_2D_SHAPE_H - -// #include "BulletCollision/CollisionShapes/btConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btConvex2dShape.java +// #ifndef BT_SPHERE_TRIANGLE_DETECTOR_H +// #define BT_SPHERE_TRIANGLE_DETECTOR_H +// #include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h" +// Targeting ../BulletCollision/SphereTriangleDetector.java -// #endif //BT_CONVEX_2D_SHAPE_H +// #endif //BT_SPHERE_TRIANGLE_DETECTOR_H -// Parsed from BulletCollision/CollisionShapes/btConvexHullShape.h +// Parsed from BulletCollision/CollisionShapes/btBox2dShape.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2587,27 +2832,22 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_HULL_SHAPE_H -// #define BT_CONVEX_HULL_SHAPE_H - -// #include "btPolyhedralConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btConvexHullShape.java - - -// Targeting ../BulletCollision/btConvexHullShapeData.java - - +// #ifndef BT_OBB_BOX_2D_SHAPE_H +// #define BT_OBB_BOX_2D_SHAPE_H -// clang-format on +// #include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h" +// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMinMax.h" +// Targeting ../BulletCollision/btBox2dShape.java -// #endif //BT_CONVEX_HULL_SHAPE_H +// #endif //BT_OBB_BOX_2D_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btConvexInternalShape.h +// Parsed from BulletCollision/CollisionShapes/btBoxShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2624,34 +2864,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_INTERNAL_SHAPE_H -// #define BT_CONVEX_INTERNAL_SHAPE_H - -// #include "btConvexShape.h" -// #include "LinearMath/btAabbUtil2.h" -// Targeting ../BulletCollision/btConvexInternalShape.java - - -// Targeting ../BulletCollision/btConvexInternalShapeData.java - - - - - -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ +// #ifndef BT_OBB_BOX_MINKOWSKI_H +// #define BT_OBB_BOX_MINKOWSKI_H -// Targeting ../BulletCollision/btConvexInternalAabbCachingShape.java +// #include "btPolyhedralConvexShape.h" +// #include "btCollisionMargin.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btMinMax.h" +// Targeting ../BulletCollision/btBoxShape.java -// #endif //BT_CONVEX_INTERNAL_SHAPE_H +// #endif //BT_OBB_BOX_MINKOWSKI_H -// Parsed from BulletCollision/CollisionShapes/btConvexPolyhedron.h +// Parsed from BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -2664,26 +2896,28 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -/**This file was written by Erwin Coumans */ +// #ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H +// #define BT_BVH_TRIANGLE_MESH_SHAPE_H -// #ifndef _BT_POLYHEDRAL_FEATURES_H -// #define _BT_POLYHEDRAL_FEATURES_H +// #include "btTriangleMeshShape.h" +// #include "btOptimizedBvh.h" +// #include "LinearMath/btAlignedAllocator.h" +// #include "btTriangleInfoMap.h" +// Targeting ../BulletCollision/btBvhTriangleMeshShape.java -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btAlignedObjectArray.h" -public static final int TEST_INTERNAL_OBJECTS = 1; -// Targeting ../BulletCollision/btFace.java +// Targeting ../BulletCollision/btTriangleMeshShapeData.java -// Targeting ../BulletCollision/btConvexPolyhedron.java +// clang-format on -// #endif //_BT_POLYHEDRAL_FEATURES_H +// #endif //BT_BVH_TRIANGLE_MESH_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btConvexShape.h + +// Parsed from BulletCollision/CollisionShapes/btCapsuleShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2700,26 +2934,35 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_SHAPE_INTERFACE1 -// #define BT_CONVEX_SHAPE_INTERFACE1 +// #ifndef BT_CAPSULE_SHAPE_H +// #define BT_CAPSULE_SHAPE_H -// #include "btCollisionShape.h" +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btCapsuleShape.java -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "btCollisionMargin.h" -// #include "LinearMath/btAlignedAllocator.h" -public static final int MAX_PREFERRED_PENETRATION_DIRECTIONS = 10; -// Targeting ../BulletCollision/btConvexShape.java +// Targeting ../BulletCollision/btCapsuleShapeX.java +// Targeting ../BulletCollision/btCapsuleShapeZ.java -// #endif //BT_CONVEX_SHAPE_INTERFACE1 +// Targeting ../BulletCollision/btCapsuleShapeData.java -// Parsed from BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + + + +// #endif //BT_CAPSULE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btCollisionMargin.h /* Bullet Continuous Collision Detection and Physics Library @@ -2735,19 +2978,20 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H -// #define BT_CONVEX_TRIANGLEMESH_SHAPE_H - -// #include "btPolyhedralConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btConvexTriangleMeshShape.java +// #ifndef BT_COLLISION_MARGIN_H +// #define BT_COLLISION_MARGIN_H +/**The CONVEX_DISTANCE_MARGIN is a default collision margin for convex collision shapes derived from btConvexInternalShape. + * This collision margin is used by Gjk and some other algorithms + * Note that when creating small objects, you need to make sure to set a smaller collision margin, using the 'setMargin' API */ +public static native @MemberGetter double CONVEX_DISTANCE_MARGIN(); +public static final double CONVEX_DISTANCE_MARGIN = CONVEX_DISTANCE_MARGIN(); // btScalar(0.1)//;//btScalar(0.01) -// #endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H +// #endif //BT_COLLISION_MARGIN_H -// Parsed from BulletCollision/CollisionShapes/btCylinderShape.h +// Parsed from BulletCollision/CollisionShapes/btCollisionShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2764,34 +3008,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_CYLINDER_MINKOWSKI_H -// #define BT_CYLINDER_MINKOWSKI_H +// #ifndef BT_COLLISION_SHAPE_H +// #define BT_COLLISION_SHAPE_H -// #include "btBoxShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btTransform.h" // #include "LinearMath/btVector3.h" -// Targeting ../BulletCollision/btCylinderShape.java - - -// Targeting ../BulletCollision/btCylinderShapeX.java - - -// Targeting ../BulletCollision/btCylinderShapeZ.java - - -// Targeting ../BulletCollision/btCylinderShapeData.java - +// #include "LinearMath/btMatrix3x3.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" //for the shape types +// Targeting ../BulletCollision/btCollisionShape.java +// Targeting ../BulletCollision/btCollisionShapeData.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ +// clang-format on -// #endif //BT_CYLINDER_MINKOWSKI_H +// #endif //BT_COLLISION_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btEmptyShape.h +// Parsed from BulletCollision/CollisionShapes/btCompoundShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2808,23 +3044,39 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_EMPTY_SHAPE_H -// #define BT_EMPTY_SHAPE_H - -// #include "btConcaveShape.h" +// #ifndef BT_COMPOUND_SHAPE_H +// #define BT_COMPOUND_SHAPE_H + +// #include "btCollisionShape.h" // #include "LinearMath/btVector3.h" // #include "LinearMath/btTransform.h" // #include "LinearMath/btMatrix3x3.h" // #include "btCollisionMargin.h" -// Targeting ../BulletCollision/btEmptyShape.java +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btCompoundShapeChild.java -// #endif //BT_EMPTY_SHAPE_H +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef btCompoundShapeChild c1, @Const @ByRef btCompoundShapeChild c2); +// Targeting ../BulletCollision/btCompoundShape.java -// Parsed from BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h +// Targeting ../BulletCollision/btCompoundShapeChildData.java + + +// Targeting ../BulletCollision/btCompoundShapeData.java + + + +// clang-format on + + + +// #endif //BT_COMPOUND_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConcaveShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2841,19 +3093,31 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_HEIGHTFIELD_TERRAIN_SHAPE_H -// #define BT_HEIGHTFIELD_TERRAIN_SHAPE_H +// #ifndef BT_CONCAVE_SHAPE_H +// #define BT_CONCAVE_SHAPE_H -// #include "btConcaveShape.h" -// #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btHeightfieldTerrainShape.java +// #include "btCollisionShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "btTriangleCallback.h" + +/** PHY_ScalarType enumerates possible scalar types. + * See the btStridingMeshInterface or btHeightfieldTerrainShape for its use */ +/** enum PHY_ScalarType */ +public static final int + PHY_FLOAT = 0, + PHY_DOUBLE = 1, + PHY_INTEGER = 2, + PHY_SHORT = 3, + PHY_FIXEDPOINT88 = 4, + PHY_UCHAR = 5; +// Targeting ../BulletCollision/btConcaveShape.java -// #endif //BT_HEIGHTFIELD_TERRAIN_SHAPE_H +// #endif //BT_CONCAVE_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btMultiSphereShape.h +// Parsed from BulletCollision/CollisionShapes/btConeShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2870,31 +3134,33 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_MULTI_SPHERE_MINKOWSKI_H -// #define BT_MULTI_SPHERE_MINKOWSKI_H +// #ifndef BT_CONE_MINKOWSKI_H +// #define BT_CONE_MINKOWSKI_H // #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btAabbUtil2.h" -// Targeting ../BulletCollision/btMultiSphereShape.java +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btConeShape.java -// Targeting ../BulletCollision/btPositionAndRadius.java +// Targeting ../BulletCollision/btConeShapeX.java -// Targeting ../BulletCollision/btMultiSphereShapeData.java +// Targeting ../BulletCollision/btConeShapeZ.java +// Targeting ../BulletCollision/btConeShapeData.java -// clang-format on -// #endif //BT_MULTI_SPHERE_MINKOWSKI_H +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// Parsed from BulletCollision/CollisionShapes/btOptimizedBvh.h + +// #endif //BT_CONE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btConvex2dShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2911,20 +3177,19 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -/**Contains contributions from Disney Studio's */ - -// #ifndef BT_OPTIMIZED_BVH_H -// #define BT_OPTIMIZED_BVH_H +// #ifndef BT_CONVEX_2D_SHAPE_H +// #define BT_CONVEX_2D_SHAPE_H -// #include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" -// Targeting ../BulletCollision/btOptimizedBvh.java +// #include "BulletCollision/CollisionShapes/btConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btConvex2dShape.java -// #endif //BT_OPTIMIZED_BVH_H +// #endif //BT_CONVEX_2D_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h +// Parsed from BulletCollision/CollisionShapes/btConvexHullShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2941,22 +3206,27 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H -// #define BT_POLYHEDRAL_CONVEX_SHAPE_H +// #ifndef BT_CONVEX_HULL_SHAPE_H +// #define BT_CONVEX_HULL_SHAPE_H -// #include "LinearMath/btMatrix3x3.h" -// #include "btConvexInternalShape.h" -// Targeting ../BulletCollision/btPolyhedralConvexShape.java +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btConvexHullShape.java -// Targeting ../BulletCollision/btPolyhedralConvexAabbCachingShape.java +// Targeting ../BulletCollision/btConvexHullShapeData.java -// #endif //BT_POLYHEDRAL_CONVEX_SHAPE_H +// clang-format on -// Parsed from BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h + +// #endif //BT_CONVEX_HULL_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexInternalShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -2973,14 +3243,15 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H -// #define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +// #ifndef BT_CONVEX_INTERNAL_SHAPE_H +// #define BT_CONVEX_INTERNAL_SHAPE_H -// #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" -// Targeting ../BulletCollision/btScaledBvhTriangleMeshShape.java +// #include "btConvexShape.h" +// #include "LinearMath/btAabbUtil2.h" +// Targeting ../BulletCollision/btConvexInternalShape.java -// Targeting ../BulletCollision/btScaledTriangleMeshShapeData.java +// Targeting ../BulletCollision/btConvexInternalShapeData.java @@ -2988,24 +3259,14 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, /**fills the dataBuffer and returns the struct name (and 0 on failure) */ - -// #endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H - - -// Parsed from BulletCollision/CollisionShapes/btSdfCollisionShape.h - -// #ifndef BT_SDF_COLLISION_SHAPE_H -// #define BT_SDF_COLLISION_SHAPE_H - -// #include "btConcaveShape.h" -// Targeting ../BulletCollision/btSdfCollisionShape.java +// Targeting ../BulletCollision/btConvexInternalAabbCachingShape.java -// #endif //BT_SDF_COLLISION_SHAPE_H +// #endif //BT_CONVEX_INTERNAL_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btShapeHull.h +// Parsed from BulletCollision/CollisionShapes/btConvexPointCloudShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3022,25 +3283,24 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -/**btShapeHull implemented by John McCutchan. */ - -// #ifndef BT_SHAPE_HULL_H -// #define BT_SHAPE_HULL_H +// #ifndef BT_CONVEX_POINT_CLOUD_SHAPE_H +// #define BT_CONVEX_POINT_CLOUD_SHAPE_H +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types // #include "LinearMath/btAlignedObjectArray.h" -// #include "BulletCollision/CollisionShapes/btConvexShape.h" -// Targeting ../BulletCollision/btShapeHull.java +// Targeting ../BulletCollision/btConvexPointCloudShape.java -// #endif //BT_SHAPE_HULL_H +// #endif //BT_CONVEX_POINT_CLOUD_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btSphereShape.h +// Parsed from BulletCollision/CollisionShapes/btConvexPolyhedron.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +Copyright (c) 2011 Advanced Micro Devices, Inc. http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -3052,19 +3312,27 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SPHERE_MINKOWSKI_H -// #define BT_SPHERE_MINKOWSKI_H -// #include "btConvexInternalShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btSphereShape.java +/**This file was written by Erwin Coumans */ + +// #ifndef _BT_POLYHEDRAL_FEATURES_H +// #define _BT_POLYHEDRAL_FEATURES_H +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btAlignedObjectArray.h" +public static final int TEST_INTERNAL_OBJECTS = 1; +// Targeting ../BulletCollision/btFace.java -// #endif //BT_SPHERE_MINKOWSKI_H +// Targeting ../BulletCollision/btConvexPolyhedron.java -// Parsed from BulletCollision/CollisionShapes/btStaticPlaneShape.h + + +// #endif //_BT_POLYHEDRAL_FEATURES_H + + +// Parsed from BulletCollision/CollisionShapes/btConvexShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3081,26 +3349,26 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_STATIC_PLANE_SHAPE_H -// #define BT_STATIC_PLANE_SHAPE_H - -// #include "btConcaveShape.h" -// Targeting ../BulletCollision/btStaticPlaneShape.java - - -// Targeting ../BulletCollision/btStaticPlaneShapeData.java - +// #ifndef BT_CONVEX_SHAPE_INTERFACE1 +// #define BT_CONVEX_SHAPE_INTERFACE1 +// #include "btCollisionShape.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// #include "LinearMath/btAlignedAllocator.h" +public static final int MAX_PREFERRED_PENETRATION_DIRECTIONS = 10; +// Targeting ../BulletCollision/btConvexShape.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //BT_STATIC_PLANE_SHAPE_H +// #endif //BT_CONVEX_SHAPE_INTERFACE1 -// Parsed from BulletCollision/CollisionShapes/btStridingMeshInterface.h +// Parsed from BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3116,43 +3384,63 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ +// #ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H +// #define BT_CONVEX_TRIANGLEMESH_SHAPE_H -// #ifndef BT_STRIDING_MESHINTERFACE_H -// #define BT_STRIDING_MESHINTERFACE_H +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btConvexTriangleMeshShape.java -// #include "LinearMath/btVector3.h" -// #include "btTriangleCallback.h" -// #include "btConcaveShape.h" -// Targeting ../BulletCollision/btStridingMeshInterface.java -// Targeting ../BulletCollision/btIntIndexData.java +// #endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H -// Targeting ../BulletCollision/btShortIntIndexData.java +// Parsed from BulletCollision/CollisionShapes/btCylinderShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: -// Targeting ../BulletCollision/btShortIntIndexTripletData.java +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_CYLINDER_MINKOWSKI_H +// #define BT_CYLINDER_MINKOWSKI_H -// Targeting ../BulletCollision/btCharIndexTripletData.java +// #include "btBoxShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btCylinderShape.java -// Targeting ../BulletCollision/btMeshPartData.java +// Targeting ../BulletCollision/btCylinderShapeX.java -// Targeting ../BulletCollision/btStridingMeshInterfaceData.java +// Targeting ../BulletCollision/btCylinderShapeZ.java +// Targeting ../BulletCollision/btCylinderShapeData.java -// clang-format on -// #endif //BT_STRIDING_MESHINTERFACE_H + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// Parsed from BulletCollision/CollisionShapes/btTetrahedronShape.h +// #endif //BT_CYLINDER_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btEmptyShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3169,19 +3457,23 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SIMPLEX_1TO4_SHAPE -// #define BT_SIMPLEX_1TO4_SHAPE +// #ifndef BT_EMPTY_SHAPE_H +// #define BT_EMPTY_SHAPE_H -// #include "btPolyhedralConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btBU_Simplex1to4.java +// #include "btConcaveShape.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "btCollisionMargin.h" +// Targeting ../BulletCollision/btEmptyShape.java -// #endif //BT_SIMPLEX_1TO4_SHAPE +// #endif //BT_EMPTY_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btTriangleCallback.h + +// Parsed from BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3198,21 +3490,19 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TRIANGLE_CALLBACK_H -// #define BT_TRIANGLE_CALLBACK_H - -// #include "LinearMath/btVector3.h" -// Targeting ../BulletCollision/btTriangleCallback.java - +// #ifndef BT_HEIGHTFIELD_TERRAIN_SHAPE_H +// #define BT_HEIGHTFIELD_TERRAIN_SHAPE_H -// Targeting ../BulletCollision/btInternalTriangleIndexCallback.java +// #include "btConcaveShape.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btHeightfieldTerrainShape.java -// #endif //BT_TRIANGLE_CALLBACK_H +// #endif //BT_HEIGHTFIELD_TERRAIN_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h +// Parsed from BulletCollision/CollisionShapes/btMaterial.h /* Bullet Continuous Collision Detection and Physics Library @@ -3229,27 +3519,52 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H -// #define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H +/** This file was created by Alex Silverman */ -// #include "btStridingMeshInterface.h" +// #ifndef BT_MATERIAL_H +// #define BT_MATERIAL_H +// Targeting ../BulletCollision/btMaterial.java + + + +// #endif // BT_MATERIAL_H + + +// Parsed from BulletCollision/CollisionShapes/btMiniSDF.h + +// #ifndef MINISDF_H +// #define MINISDF_H + +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAabbUtil2.h" // #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btScalar.h" -// Targeting ../BulletCollision/btIndexedMesh.java +// Targeting ../BulletCollision/btMultiIndex.java -// Targeting ../BulletCollision/btTriangleIndexVertexArray.java +// Targeting ../BulletCollision/btAlignedBox3d.java +// Targeting ../BulletCollision/btShapeMatrix.java -// #endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H +// Targeting ../BulletCollision/btShapeGradients.java -// Parsed from BulletCollision/CollisionShapes/btTriangleInfoMap.h + +// Targeting ../BulletCollision/btCell32.java + + +// Targeting ../BulletCollision/btMiniSDF.java + + + +// #endif //MINISDF_H + + +// Parsed from BulletCollision/CollisionShapes/btMinkowskiSumShape.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2010 Erwin Coumans http://bulletphysics.org +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -3262,47 +3577,50 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef _BT_TRIANGLE_INFO_MAP_H -// #define _BT_TRIANGLE_INFO_MAP_H - -// #include "LinearMath/btHashMap.h" -// #include "LinearMath/btSerializer.h" - -/**for btTriangleInfo m_flags */ -public static final int TRI_INFO_V0V1_CONVEX = 1; -public static final int TRI_INFO_V1V2_CONVEX = 2; -public static final int TRI_INFO_V2V0_CONVEX = 4; - -public static final int TRI_INFO_V0V1_SWAP_NORMALB = 8; -public static final int TRI_INFO_V1V2_SWAP_NORMALB = 16; -public static final int TRI_INFO_V2V0_SWAP_NORMALB = 32; -// Targeting ../BulletCollision/btTriangleInfo.java - +// #ifndef BT_MINKOWSKI_SUM_SHAPE_H +// #define BT_MINKOWSKI_SUM_SHAPE_H -// Targeting ../BulletCollision/btTriangleInfoMap.java +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btMinkowskiSumShape.java -// Targeting ../BulletCollision/btTriangleInfoData.java +// #endif //BT_MINKOWSKI_SUM_SHAPE_H -// Targeting ../BulletCollision/btTriangleInfoMapData.java +// Parsed from BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org -// clang-format on +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/** This file was created by Alex Silverman */ -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ +// #ifndef BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H +// #define BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H +// #include "btBvhTriangleMeshShape.h" +// #include "btMaterial.h" +// Targeting ../BulletCollision/btMultimaterialTriangleMeshShape.java -/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -// #endif //_BT_TRIANGLE_INFO_MAP_H +// #endif //BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H -// Parsed from BulletCollision/CollisionShapes/btTriangleMesh.h +// Parsed from BulletCollision/CollisionShapes/btMultiSphereShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3319,20 +3637,31 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TRIANGLE_MESH_H -// #define BT_TRIANGLE_MESH_H +// #ifndef BT_MULTI_SPHERE_MINKOWSKI_H +// #define BT_MULTI_SPHERE_MINKOWSKI_H -// #include "btTriangleIndexVertexArray.h" -// #include "LinearMath/btVector3.h" +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types // #include "LinearMath/btAlignedObjectArray.h" -// Targeting ../BulletCollision/btTriangleMesh.java +// #include "LinearMath/btAabbUtil2.h" +// Targeting ../BulletCollision/btMultiSphereShape.java + +// Targeting ../BulletCollision/btPositionAndRadius.java -// #endif //BT_TRIANGLE_MESH_H +// Targeting ../BulletCollision/btMultiSphereShapeData.java + + + +// clang-format on -// Parsed from BulletCollision/CollisionShapes/btTriangleMeshShape.h + +// #endif //BT_MULTI_SPHERE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btOptimizedBvh.h /* Bullet Continuous Collision Detection and Physics Library @@ -3349,19 +3678,20 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_TRIANGLE_MESH_SHAPE_H -// #define BT_TRIANGLE_MESH_SHAPE_H +/**Contains contributions from Disney Studio's */ -// #include "btConcaveShape.h" -// #include "btStridingMeshInterface.h" -// Targeting ../BulletCollision/btTriangleMeshShape.java +// #ifndef BT_OPTIMIZED_BVH_H +// #define BT_OPTIMIZED_BVH_H +// #include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" +// Targeting ../BulletCollision/btOptimizedBvh.java -// #endif //BT_TRIANGLE_MESH_SHAPE_H +// #endif //BT_OPTIMIZED_BVH_H -// Parsed from BulletCollision/CollisionShapes/btTriangleShape.h + +// Parsed from BulletCollision/CollisionShapes/btPolyhedralConvexShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3378,19 +3708,22 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_OBB_TRIANGLE_MINKOWSKI_H -// #define BT_OBB_TRIANGLE_MINKOWSKI_H +// #ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H +// #define BT_POLYHEDRAL_CONVEX_SHAPE_H -// #include "btConvexShape.h" -// #include "btBoxShape.h" -// Targeting ../BulletCollision/btTriangleShape.java +// #include "LinearMath/btMatrix3x3.h" +// #include "btConvexInternalShape.h" +// Targeting ../BulletCollision/btPolyhedralConvexShape.java +// Targeting ../BulletCollision/btPolyhedralConvexAabbCachingShape.java -// #endif //BT_OBB_TRIANGLE_MINKOWSKI_H -// Parsed from BulletCollision/CollisionShapes/btUniformScalingShape.h +// #endif //BT_POLYHEDRAL_CONVEX_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h /* Bullet Continuous Collision Detection and Physics Library @@ -3407,36 +3740,48 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_UNIFORM_SCALING_SHAPE_H -// #define BT_UNIFORM_SCALING_SHAPE_H +// #ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H +// #define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H -// #include "btConvexShape.h" -// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" -// Targeting ../BulletCollision/btUniformScalingShape.java +// #include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h" +// Targeting ../BulletCollision/btScaledBvhTriangleMeshShape.java +// Targeting ../BulletCollision/btScaledTriangleMeshShapeData.java -// #endif //BT_UNIFORM_SCALING_SHAPE_H -// Parsed from BulletCollision/Gimpact/btGImpactShape.h -/** \file btGImpactShape.h -@author Francisco Len N�jera -*/ -/* -This source file is part of GIMPACT Library. -For the latest info, see http://gimpact.sourceforge.net/ +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ -Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. -email: projectileman@yahoo.com +// #endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btSdfCollisionShape.h + +// #ifndef BT_SDF_COLLISION_SHAPE_H +// #define BT_SDF_COLLISION_SHAPE_H + +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btSdfCollisionShape.java + + + +// #endif //BT_SDF_COLLISION_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btShapeHull.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. @@ -3444,46 +3789,1158 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef GIMPACT_SHAPE_H -// #define GIMPACT_SHAPE_H +/**btShapeHull implemented by John McCutchan. */ -// #include "BulletCollision/CollisionShapes/btCollisionShape.h" -// #include "BulletCollision/CollisionShapes/btTriangleShape.h" -// #include "BulletCollision/CollisionShapes/btStridingMeshInterface.h" -// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" -// #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" -// #include "BulletCollision/CollisionShapes/btConcaveShape.h" -// #include "BulletCollision/CollisionShapes/btTetrahedronShape.h" -// #include "LinearMath/btVector3.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btMatrix3x3.h" -// #include "LinearMath/btAlignedObjectArray.h" +// #ifndef BT_SHAPE_HULL_H +// #define BT_SHAPE_HULL_H -// #include "btGImpactQuantizedBvh.h" // box tree class +// #include "LinearMath/btAlignedObjectArray.h" +// #include "BulletCollision/CollisionShapes/btConvexShape.h" +// Targeting ../BulletCollision/btShapeHull.java -/** declare Quantized trees, (you can change to float based trees) */ -/** enum eGIMPACT_SHAPE_TYPE */ -public static final int - CONST_GIMPACT_COMPOUND_SHAPE = 0, - CONST_GIMPACT_TRIMESH_SHAPE_PART = 1, - CONST_GIMPACT_TRIMESH_SHAPE = 2; -// Targeting ../BulletCollision/btTetrahedronShapeEx.java +// #endif //BT_SHAPE_HULL_H -// Targeting ../BulletCollision/btGImpactShapeInterface.java +// Parsed from BulletCollision/CollisionShapes/btSphereShape.h -// Targeting ../BulletCollision/btGImpactCompoundShape.java +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: -// Targeting ../BulletCollision/btGImpactMeshShapePart.java +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +// #ifndef BT_SPHERE_MINKOWSKI_H +// #define BT_SPHERE_MINKOWSKI_H +// #include "btConvexInternalShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btSphereShape.java -// Targeting ../BulletCollision/btGImpactMeshShape.java -// Targeting ../BulletCollision/btGImpactMeshShapeData.java +// #endif //BT_SPHERE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btStaticPlaneShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_STATIC_PLANE_SHAPE_H +// #define BT_STATIC_PLANE_SHAPE_H + +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btStaticPlaneShape.java + + +// Targeting ../BulletCollision/btStaticPlaneShapeData.java + + + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //BT_STATIC_PLANE_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btStridingMeshInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_STRIDING_MESHINTERFACE_H +// #define BT_STRIDING_MESHINTERFACE_H + +// #include "LinearMath/btVector3.h" +// #include "btTriangleCallback.h" +// #include "btConcaveShape.h" +// Targeting ../BulletCollision/btStridingMeshInterface.java + + +// Targeting ../BulletCollision/btIntIndexData.java + + +// Targeting ../BulletCollision/btShortIntIndexData.java + + +// Targeting ../BulletCollision/btShortIntIndexTripletData.java + + +// Targeting ../BulletCollision/btCharIndexTripletData.java + + +// Targeting ../BulletCollision/btMeshPartData.java + + +// Targeting ../BulletCollision/btStridingMeshInterfaceData.java + + + +// clang-format on + + + +// #endif //BT_STRIDING_MESHINTERFACE_H + + +// Parsed from BulletCollision/CollisionShapes/btTetrahedronShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SIMPLEX_1TO4_SHAPE +// #define BT_SIMPLEX_1TO4_SHAPE + +// #include "btPolyhedralConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btBU_Simplex1to4.java + + + +// #endif //BT_SIMPLEX_1TO4_SHAPE + + +// Parsed from BulletCollision/CollisionShapes/btTriangleBuffer.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_BUFFER_H +// #define BT_TRIANGLE_BUFFER_H + +// #include "btTriangleCallback.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btTriangle.java + + +// Targeting ../BulletCollision/btTriangleBuffer.java + + + +// #endif //BT_TRIANGLE_BUFFER_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleCallback.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_CALLBACK_H +// #define BT_TRIANGLE_CALLBACK_H + +// #include "LinearMath/btVector3.h" +// Targeting ../BulletCollision/btTriangleCallback.java + + +// Targeting ../BulletCollision/btInternalTriangleIndexCallback.java + + + +// #endif //BT_TRIANGLE_CALLBACK_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_INDEX_VERTEX_ARRAY_H +// #define BT_TRIANGLE_INDEX_VERTEX_ARRAY_H + +// #include "btStridingMeshInterface.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btScalar.h" +// Targeting ../BulletCollision/btIndexedMesh.java + + +// Targeting ../BulletCollision/btTriangleIndexVertexArray.java + + + +// #endif //BT_TRIANGLE_INDEX_VERTEX_ARRAY_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleIndexVertexMaterialArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**This file was created by Alex Silverman */ + +// #ifndef BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H +// #define BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H + +// #include "btTriangleIndexVertexArray.h" +// Targeting ../BulletCollision/btMaterialProperties.java + + +// Targeting ../BulletCollision/btTriangleIndexVertexMaterialArray.java + + + +// #endif //BT_MULTIMATERIAL_TRIANGLE_INDEX_VERTEX_ARRAY_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleInfoMap.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2010 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef _BT_TRIANGLE_INFO_MAP_H +// #define _BT_TRIANGLE_INFO_MAP_H + +// #include "LinearMath/btHashMap.h" +// #include "LinearMath/btSerializer.h" + +/**for btTriangleInfo m_flags */ +public static final int TRI_INFO_V0V1_CONVEX = 1; +public static final int TRI_INFO_V1V2_CONVEX = 2; +public static final int TRI_INFO_V2V0_CONVEX = 4; + +public static final int TRI_INFO_V0V1_SWAP_NORMALB = 8; +public static final int TRI_INFO_V1V2_SWAP_NORMALB = 16; +public static final int TRI_INFO_V2V0_SWAP_NORMALB = 32; +// Targeting ../BulletCollision/btTriangleInfo.java + + +// Targeting ../BulletCollision/btTriangleInfoMap.java + + +// Targeting ../BulletCollision/btTriangleInfoData.java + + +// Targeting ../BulletCollision/btTriangleInfoMapData.java + + + +// clang-format on + + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +/**fills the dataBuffer and returns the struct name (and 0 on failure) */ + + +// #endif //_BT_TRIANGLE_INFO_MAP_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleMesh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_MESH_H +// #define BT_TRIANGLE_MESH_H + +// #include "btTriangleIndexVertexArray.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletCollision/btTriangleMesh.java + + + +// #endif //BT_TRIANGLE_MESH_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleMeshShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_TRIANGLE_MESH_SHAPE_H +// #define BT_TRIANGLE_MESH_SHAPE_H + +// #include "btConcaveShape.h" +// #include "btStridingMeshInterface.h" +// Targeting ../BulletCollision/btTriangleMeshShape.java + + + +// #endif //BT_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/CollisionShapes/btTriangleShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_OBB_TRIANGLE_MINKOWSKI_H +// #define BT_OBB_TRIANGLE_MINKOWSKI_H + +// #include "btConvexShape.h" +// #include "btBoxShape.h" +// Targeting ../BulletCollision/btTriangleShape.java + + + +// #endif //BT_OBB_TRIANGLE_MINKOWSKI_H + + +// Parsed from BulletCollision/CollisionShapes/btUniformScalingShape.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_UNIFORM_SCALING_SHAPE_H +// #define BT_UNIFORM_SCALING_SHAPE_H + +// #include "btConvexShape.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// Targeting ../BulletCollision/btUniformScalingShape.java + + + +// #endif //BT_UNIFORM_SCALING_SHAPE_H + + +// Parsed from BulletCollision/Gimpact/btBoxCollision.h + +// #ifndef BT_BOX_COLLISION_H_INCLUDED +// #define BT_BOX_COLLISION_H_INCLUDED + +/** \file gim_box_collision.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "LinearMath/btTransform.h" + +/**Swap numbers */ +// #define BT_SWAP_NUMBERS(a, b) +// { +// a = a + b; +// b = a - b; +// a = a - b; +// } + +// #define BT_MAX(a, b) (a < b ? b : a) +// #define BT_MIN(a, b) (a > b ? b : a) + +// #define BT_GREATER(x, y) btFabs(x) > (y) + +// #define BT_MAX3(a, b, c) BT_MAX(a, BT_MAX(b, c)) +// #define BT_MIN3(a, b, c) BT_MIN(a, BT_MIN(b, c)) + +/** enum eBT_PLANE_INTERSECTION_TYPE */ +public static final int + BT_CONST_BACK_PLANE = 0, + BT_CONST_COLLIDE_PLANE = 1, + BT_CONST_FRONT_PLANE = 2; + +//SIMD_FORCE_INLINE bool test_cross_edge_box( +// const btVector3 & edge, +// const btVector3 & absolute_edge, +// const btVector3 & pointa, +// const btVector3 & pointb, const btVector3 & extend, +// int dir_index0, +// int dir_index1 +// int component_index0, +// int component_index1) +//{ +// // dir coords are -z and y +// +// const btScalar dir0 = -edge[dir_index0]; +// const btScalar dir1 = edge[dir_index1]; +// btScalar pmin = pointa[component_index0]*dir0 + pointa[component_index1]*dir1; +// btScalar pmax = pointb[component_index0]*dir0 + pointb[component_index1]*dir1; +// //find minmax +// if(pmin>pmax) +// { +// BT_SWAP_NUMBERS(pmin,pmax); +// } +// //find extends +// const btScalar rad = extend[component_index0] * absolute_edge[dir_index0] + +// extend[component_index1] * absolute_edge[dir_index1]; +// +// if(pmin>rad || -rad>pmax) return false; +// return true; +//} +// +//SIMD_FORCE_INLINE bool test_cross_edge_box_X_axis( +// const btVector3 & edge, +// const btVector3 & absolute_edge, +// const btVector3 & pointa, +// const btVector3 & pointb, btVector3 & extend) +//{ +// +// return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,2,1,1,2); +//} +// +// +//SIMD_FORCE_INLINE bool test_cross_edge_box_Y_axis( +// const btVector3 & edge, +// const btVector3 & absolute_edge, +// const btVector3 & pointa, +// const btVector3 & pointb, btVector3 & extend) +//{ +// +// return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,0,2,2,0); +//} +// +//SIMD_FORCE_INLINE bool test_cross_edge_box_Z_axis( +// const btVector3 & edge, +// const btVector3 & absolute_edge, +// const btVector3 & pointa, +// const btVector3 & pointb, btVector3 & extend) +//{ +// +// return test_cross_edge_box(edge,absolute_edge,pointa,pointb,extend,1,0,0,1); +//} + +// #define TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, i_dir_0, i_dir_1, i_comp_0, i_comp_1) +// { +// const btScalar dir0 = -edge[i_dir_0]; +// const btScalar dir1 = edge[i_dir_1]; +// btScalar pmin = pointa[i_comp_0] * dir0 + pointa[i_comp_1] * dir1; +// btScalar pmax = pointb[i_comp_0] * dir0 + pointb[i_comp_1] * dir1; +// if (pmin > pmax) +// { +// BT_SWAP_NUMBERS(pmin, pmax); +// } +// const btScalar abs_dir0 = absolute_edge[i_dir_0]; +// const btScalar abs_dir1 = absolute_edge[i_dir_1]; +// const btScalar rad = _extend[i_comp_0] * abs_dir0 + _extend[i_comp_1] * abs_dir1; +// if (pmin > rad || -rad > pmax) return false; +// } + +// #define TEST_CROSS_EDGE_BOX_X_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend) +// { +// TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 2, 1, 1, 2); +// } + +// #define TEST_CROSS_EDGE_BOX_Y_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend) +// { +// TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 0, 2, 2, 0); +// } + +// #define TEST_CROSS_EDGE_BOX_Z_AXIS_MCR(edge, absolute_edge, pointa, pointb, _extend) +// { +// TEST_CROSS_EDGE_BOX_MCR(edge, absolute_edge, pointa, pointb, _extend, 1, 0, 0, 1); +// } + +/** Returns the dot product between a vec3f and the col of a matrix */ +public static native @Cast("btScalar") float bt_mat3_dot_col( + @Const @ByRef btMatrix3x3 mat, @Const @ByRef btVector3 vec3, int colindex); +// Targeting ../BulletCollision/BT_BOX_BOX_TRANSFORM_CACHE.java + + + +public static final double BOX_PLANE_EPSILON = 0.000001f; + +/** Axis aligned box */ + +/** Compairison of transformation objects */ +public static native @Cast("bool") boolean btCompareTransformsEqual(@Const @ByRef btTransform t1, @Const @ByRef btTransform t2); + +// #endif // GIM_BOX_COLLISION_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btClipPolygon.h + +// #ifndef BT_CLIP_POLYGON_H_INCLUDED +// #define BT_CLIP_POLYGON_H_INCLUDED + +/** \file btClipPolygon.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btGeometryUtil.h" + +public static native @Cast("btScalar") float bt_distance_point_plane(@Const @ByRef btVector4 plane, @Const @ByRef btVector3 point); + +/** Vector blending +Takes two vectors a, b, blends them together*/ +public static native void bt_vec_blend(@ByRef btVector3 vr, @Const @ByRef btVector3 va, @Const @ByRef btVector3 vb, @Cast("btScalar") float blend_factor); + +/** This function calcs the distance from a 3D plane */ +public static native void bt_plane_clip_polygon_collect( + @Const @ByRef btVector3 point0, + @Const @ByRef btVector3 point1, + @Cast("btScalar") float dist0, + @Cast("btScalar") float dist1, + btVector3 clipped, + @ByRef IntPointer clipped_count); +public static native void bt_plane_clip_polygon_collect( + @Const @ByRef btVector3 point0, + @Const @ByRef btVector3 point1, + @Cast("btScalar") float dist0, + @Cast("btScalar") float dist1, + btVector3 clipped, + @ByRef IntBuffer clipped_count); +public static native void bt_plane_clip_polygon_collect( + @Const @ByRef btVector3 point0, + @Const @ByRef btVector3 point1, + @Cast("btScalar") float dist0, + @Cast("btScalar") float dist1, + btVector3 clipped, + @ByRef int[] clipped_count); + +/** Clips a polygon by a plane +/** +*@return The count of the clipped counts +*/ +public static native int bt_plane_clip_polygon( + @Const @ByRef btVector4 plane, + @Const btVector3 polygon_points, + int polygon_point_count, + btVector3 clipped); + +/** Clips a polygon by a plane +/** +*@param clipped must be an array of 16 points. +*@return The count of the clipped counts +*/ +public static native int bt_plane_clip_triangle( + @Const @ByRef btVector4 plane, + @Const @ByRef btVector3 point0, + @Const @ByRef btVector3 point1, + @Const @ByRef btVector3 point2, + btVector3 clipped +); + +// #endif // GIM_TRI_COLLISION_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btCompoundFromGimpact.h + +// #ifndef BT_COMPOUND_FROM_GIMPACT +// #define BT_COMPOUND_FROM_GIMPACT + +// #include "BulletCollision/CollisionShapes/btCompoundShape.h" +// #include "btGImpactShape.h" +// #include "BulletCollision/NarrowPhaseCollision/btRaycastCallback.h" +// Targeting ../BulletCollision/btCompoundFromGimpactShape.java + + +// Targeting ../BulletCollision/MyCallback.java + + +// Targeting ../BulletCollision/MyInternalTriangleIndexCallback.java + + + +public static native btCompoundShape btCreateCompoundFromGimpactShape(@Const btGImpactMeshShape gimpactMesh, @Cast("btScalar") float depth); + +// #endif //BT_COMPOUND_FROM_GIMPACT + + +// Parsed from BulletCollision/Gimpact/btContactProcessing.h + +// #ifndef BT_CONTACT_H_INCLUDED +// #define BT_CONTACT_H_INCLUDED + +/** \file gim_contact.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btTriangleShapeEx.h" +// #include "btContactProcessingStructs.h" +// Targeting ../BulletCollision/btContactArray.java + + + +// #endif // GIM_CONTACT_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btContactProcessingStructs.h + +// #ifndef BT_CONTACT_H_STRUCTS_INCLUDED +// #define BT_CONTACT_H_STRUCTS_INCLUDED + +/** \file gim_contact.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btAlignedObjectArray.h" +// #include "btTriangleShapeEx.h" + +/** +Configuration var for applying interpolation of contact normals +*/ +public static final int NORMAL_CONTACT_AVERAGE = 1; + +public static final double CONTACT_DIFF_EPSILON = 0.00001f; +// Targeting ../BulletCollision/GIM_CONTACT.java + + + +// #endif // BT_CONTACT_H_STRUCTS_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btGImpactBvh.h + +// #ifndef BT_GIMPACT_BVH_H_INCLUDED +// #define BT_GIMPACT_BVH_H_INCLUDED + +/** \file gim_box_set.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "LinearMath/btAlignedObjectArray.h" + +// #include "btBoxCollision.h" +// #include "btTriangleShapeEx.h" +// #include "btGImpactBvhStructs.h" +// Targeting ../BulletCollision/btPairSet.java + + +// Targeting ../BulletCollision/GIM_BVH_DATA_ARRAY.java + + +// Targeting ../BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java + + +// Targeting ../BulletCollision/btBvhTree.java + + +// Targeting ../BulletCollision/btPrimitiveManagerBase.java + + +// Targeting ../BulletCollision/btGImpactBvh.java + + + +// #endif // BT_GIMPACT_BVH_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btGImpactBvhStructs.h + +// #ifndef GIM_BOX_SET_STRUCT_H_INCLUDED +// #define GIM_BOX_SET_STRUCT_H_INCLUDED + +/** \file gim_box_set.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "LinearMath/btAlignedObjectArray.h" + +// #include "btBoxCollision.h" +// #include "btTriangleShapeEx.h" +// #include "gim_pair.h" +// Targeting ../BulletCollision/GIM_BVH_DATA.java + + +// Targeting ../BulletCollision/GIM_BVH_TREE_NODE.java + + + +// #endif // GIM_BOXPRUNING_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btGImpactCollisionAlgorithm.h + +/** \file btGImpactShape.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H +// #define BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H + +// #include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" + +// #include "LinearMath/btAlignedObjectArray.h" + +// #include "btGImpactShape.h" +// #include "BulletCollision/CollisionShapes/btStaticPlaneShape.h" +// #include "BulletCollision/CollisionShapes/btCompoundShape.h" +// #include "BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h" +// #include "LinearMath/btIDebugDraw.h" +// #include "BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h" +// Targeting ../BulletCollision/btGImpactCollisionAlgorithm.java + + + +//algorithm details +//#define BULLET_TRIANGLE_COLLISION 1 +public static final int GIMPACT_VS_PLANE_COLLISION = 1; + +// #endif //BT_GIMPACT_BVH_CONCAVE_COLLISION_ALGORITHM_H + + +// Parsed from BulletCollision/Gimpact/btGImpactMassUtil.h + +/** \file btGImpactMassUtil.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef GIMPACT_MASS_UTIL_H +// #define GIMPACT_MASS_UTIL_H + +// #include "LinearMath/btTransform.h" + +public static native @ByVal btVector3 gim_inertia_add_transformed( + @Const @ByRef btVector3 source_inertia, @Const @ByRef btVector3 added_inertia, @Const @ByRef btTransform transform); + +public static native @ByVal btVector3 gim_get_point_inertia(@Const @ByRef btVector3 point, @Cast("btScalar") float mass); + +// #endif //GIMPACT_MESH_SHAPE_H + + +// Parsed from BulletCollision/Gimpact/btGImpactQuantizedBvh.h + +// #ifndef GIM_QUANTIZED_SET_H_INCLUDED +// #define GIM_QUANTIZED_SET_H_INCLUDED + +/** \file btGImpactQuantizedBvh.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "btGImpactBvh.h" +// #include "btQuantization.h" +// #include "btGImpactQuantizedBvhStructs.h" +// Targeting ../BulletCollision/GIM_QUANTIZED_BVH_NODE_ARRAY.java + + +// Targeting ../BulletCollision/btQuantizedBvhTree.java + + +// Targeting ../BulletCollision/btGImpactQuantizedBvh.java + + + +// #endif // GIM_BOXPRUNING_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btGImpactQuantizedBvhStructs.h + +// #ifndef GIM_QUANTIZED_SET_STRUCTS_H_INCLUDED +// #define GIM_QUANTIZED_SET_STRUCTS_H_INCLUDED + +/** \file btGImpactQuantizedBvh.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "btGImpactBvh.h" +// #include "btQuantization.h" +// Targeting ../BulletCollision/BT_QUANTIZED_BVH_NODE.java + + + +// #endif // GIM_QUANTIZED_SET_STRUCTS_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btGImpactShape.h + +/** \file btGImpactShape.h +@author Francisco Len N�jera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef GIMPACT_SHAPE_H +// #define GIMPACT_SHAPE_H + +// #include "BulletCollision/CollisionShapes/btCollisionShape.h" +// #include "BulletCollision/CollisionShapes/btTriangleShape.h" +// #include "BulletCollision/CollisionShapes/btStridingMeshInterface.h" +// #include "BulletCollision/CollisionShapes/btCollisionMargin.h" +// #include "BulletCollision/CollisionDispatch/btCollisionWorld.h" +// #include "BulletCollision/CollisionShapes/btConcaveShape.h" +// #include "BulletCollision/CollisionShapes/btTetrahedronShape.h" +// #include "LinearMath/btVector3.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btMatrix3x3.h" +// #include "LinearMath/btAlignedObjectArray.h" + +// #include "btGImpactQuantizedBvh.h" // box tree class + +/** declare Quantized trees, (you can change to float based trees) */ + +/** enum eGIMPACT_SHAPE_TYPE */ +public static final int + CONST_GIMPACT_COMPOUND_SHAPE = 0, + CONST_GIMPACT_TRIMESH_SHAPE_PART = 1, + CONST_GIMPACT_TRIMESH_SHAPE = 2; +// Targeting ../BulletCollision/btTetrahedronShapeEx.java + + +// Targeting ../BulletCollision/btGImpactShapeInterface.java + + +// Targeting ../BulletCollision/btGImpactCompoundShape.java + + +// Targeting ../BulletCollision/btGImpactMeshShapePart.java + + +// Targeting ../BulletCollision/btGImpactMeshShape.java + + +// Targeting ../BulletCollision/btGImpactMeshShapeData.java @@ -3492,4 +4949,272 @@ public static native void btFindPenetrSegment(btMprSimplex_t portal, // #endif //GIMPACT_MESH_SHAPE_H +// Parsed from BulletCollision/Gimpact/btGenericPoolAllocator.h + +/** \file btGenericPoolAllocator.h +@author Francisco Leon Najera. email projectileman\yahoo.com +

+General purpose allocator class +*/ +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_GENERIC_POOL_ALLOCATOR_H +// #define BT_GENERIC_POOL_ALLOCATOR_H + +// #include +// #include +// #include +// #include "LinearMath/btAlignedAllocator.h" + +// #define BT_UINT_MAX UINT_MAX +public static final int BT_DEFAULT_MAX_POOLS = 16; +// Targeting ../BulletCollision/btGenericMemoryPool.java + + +// Targeting ../BulletCollision/btGenericPoolAllocator.java + + + +public static native Pointer btPoolAlloc(@Cast("size_t") long size); +public static native Pointer btPoolRealloc(Pointer ptr, @Cast("size_t") long oldsize, @Cast("size_t") long newsize); +public static native void btPoolFree(Pointer ptr); + +// #endif + + +// Parsed from BulletCollision/Gimpact/btGeometryOperations.h + +// #ifndef BT_BASIC_GEOMETRY_OPERATIONS_H_INCLUDED +// #define BT_BASIC_GEOMETRY_OPERATIONS_H_INCLUDED + +/** \file btGeometryOperations.h +*@author Francisco Leon Najera +

+*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "btBoxCollision.h" + +public static final double PLANEDIREPSILON = 0.0000001f; +public static final double PARALELENORMALS = 0.000001f; + +// #define BT_CLAMP(number, minval, maxval) (number < minval ? minval : (number > maxval ? maxval : number)) + +/** Calc a plane from a triangle edge an a normal. plane is a vec4f */ +public static native void bt_edge_plane(@Const @ByRef btVector3 e1, @Const @ByRef btVector3 e2, @Const @ByRef btVector3 normal, @ByRef btVector4 plane); + +//***************** SEGMENT and LINE FUNCTIONS **********************************/// + +/** Finds the closest point(cp) to (v) on a segment (e1,e2) + */ +public static native void bt_closest_point_on_segment( + @ByRef btVector3 cp, @Const @ByRef btVector3 v, + @Const @ByRef btVector3 e1, @Const @ByRef btVector3 e2); + +/** line plane collision +/** +*@return + -0 if the ray never intersects + -1 if the ray collides in front + -2 if the ray collides in back +*/ + +public static native int bt_line_plane_collision( + @Const @ByRef btVector4 plane, + @Const @ByRef btVector3 vDir, + @Const @ByRef btVector3 vPoint, + @ByRef btVector3 pout, + @Cast("btScalar*") @ByRef FloatPointer tparam, + @Cast("btScalar") float tmin, @Cast("btScalar") float tmax); +public static native int bt_line_plane_collision( + @Const @ByRef btVector4 plane, + @Const @ByRef btVector3 vDir, + @Const @ByRef btVector3 vPoint, + @ByRef btVector3 pout, + @Cast("btScalar*") @ByRef FloatBuffer tparam, + @Cast("btScalar") float tmin, @Cast("btScalar") float tmax); +public static native int bt_line_plane_collision( + @Const @ByRef btVector4 plane, + @Const @ByRef btVector3 vDir, + @Const @ByRef btVector3 vPoint, + @ByRef btVector3 pout, + @Cast("btScalar*") @ByRef float[] tparam, + @Cast("btScalar") float tmin, @Cast("btScalar") float tmax); + +/** Find closest points on segments */ +public static native void bt_segment_collision( + @Const @ByRef btVector3 vA1, + @Const @ByRef btVector3 vA2, + @Const @ByRef btVector3 vB1, + @Const @ByRef btVector3 vB2, + @ByRef btVector3 vPointA, + @ByRef btVector3 vPointB); + +// #endif // GIM_VECTOR_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btQuantization.h + +// #ifndef BT_GIMPACT_QUANTIZATION_H_INCLUDED +// #define BT_GIMPACT_QUANTIZATION_H_INCLUDED + +/** \file btQuantization.h +*@author Francisco Leon Najera +

+*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #include "LinearMath/btTransform.h" + +public static native void bt_calc_quantization_parameters( + @ByRef btVector3 outMinBound, + @ByRef btVector3 outMaxBound, + @ByRef btVector3 bvhQuantization, + @Const @ByRef btVector3 srcMinBound, @Const @ByRef btVector3 srcMaxBound, + @Cast("btScalar") float quantizationMargin); + +public static native void bt_quantize_clamp( + @Cast("unsigned short*") ShortPointer out, + @Const @ByRef btVector3 point, + @Const @ByRef btVector3 min_bound, + @Const @ByRef btVector3 max_bound, + @Const @ByRef btVector3 bvhQuantization); +public static native void bt_quantize_clamp( + @Cast("unsigned short*") ShortBuffer out, + @Const @ByRef btVector3 point, + @Const @ByRef btVector3 min_bound, + @Const @ByRef btVector3 max_bound, + @Const @ByRef btVector3 bvhQuantization); +public static native void bt_quantize_clamp( + @Cast("unsigned short*") short[] out, + @Const @ByRef btVector3 point, + @Const @ByRef btVector3 min_bound, + @Const @ByRef btVector3 max_bound, + @Const @ByRef btVector3 bvhQuantization); + +public static native @ByVal btVector3 bt_unquantize( + @Cast("const unsigned short*") ShortPointer vecIn, + @Const @ByRef btVector3 offset, + @Const @ByRef btVector3 bvhQuantization); +public static native @ByVal btVector3 bt_unquantize( + @Cast("const unsigned short*") ShortBuffer vecIn, + @Const @ByRef btVector3 offset, + @Const @ByRef btVector3 bvhQuantization); +public static native @ByVal btVector3 bt_unquantize( + @Cast("const unsigned short*") short[] vecIn, + @Const @ByRef btVector3 offset, + @Const @ByRef btVector3 bvhQuantization); + +// #endif // BT_GIMPACT_QUANTIZATION_H_INCLUDED + + +// Parsed from BulletCollision/Gimpact/btTriangleShapeEx.h + +/** \file btGImpactShape.h +@author Francisco Leon Najera +*/ +/* +This source file is part of GIMPACT Library. + +For the latest info, see http://gimpact.sourceforge.net/ + +Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371. +email: projectileman@yahoo.com + + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef GIMPACT_TRIANGLE_SHAPE_EX_H +// #define GIMPACT_TRIANGLE_SHAPE_EX_H + +// #include "BulletCollision/CollisionShapes/btCollisionShape.h" +// #include "BulletCollision/CollisionShapes/btTriangleShape.h" +// #include "btBoxCollision.h" +// #include "btClipPolygon.h" +// #include "btGeometryOperations.h" + +public static final int MAX_TRI_CLIPPING = 16; +// Targeting ../BulletCollision/GIM_TRIANGLE_CONTACT.java + + +// Targeting ../BulletCollision/btPrimitiveTriangle.java + + +// Targeting ../BulletCollision/btTriangleShapeEx.java + + + +// #endif //GIMPACT_TRIANGLE_MESH_SHAPE_H + + +// Parsed from BulletCollision/Gimpact/gim_pair.h + +// #ifndef GIM_PAIR_H +// #define GIM_PAIR_H +// Targeting ../BulletCollision/GIM_PAIR.java + + + +// #endif //GIM_PAIR_H + + + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index 956840024d6..0a32c4c1559 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -170,9 +170,6 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" // #include "btConjugateResidual.h" // #include "btConjugateGradient.h" -// Targeting ../BulletSoftBody/btCollisionObjectWrapper.java - - // Targeting ../BulletSoftBody/btDeformableBodySolver.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index f341b571bb9..d5a986bd87d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -758,6 +758,12 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // Targeting ../LinearMath/btIntArrayArray.java +// Targeting ../LinearMath/btUnsignedIntArrayArray.java + + +// Targeting ../LinearMath/btDoubleArrayArray.java + + // #endif //BT_OBJECT_ARRAY__ From 0cf75c4dcce1ffb9bcd9d10aed45586a09050ec6 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Fri, 11 Mar 2022 13:57:34 +0800 Subject: [PATCH 53/81] Complete mapping of BulletDynamics library --- .../bullet/presets/BulletDynamics.java | 89 ++++++++++--------- 1 file changed, 49 insertions(+), 40 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index e5a059ba554..6225a347989 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -43,6 +43,7 @@ "BulletDynamics/ConstraintSolver/btBatchedConstraints.h", "BulletDynamics/ConstraintSolver/btConeTwistConstraint.h", "BulletDynamics/ConstraintSolver/btConstraintSolver.h", + "BulletDynamics/ConstraintSolver/btContactConstraint.h", "BulletDynamics/ConstraintSolver/btContactSolverInfo.h", "BulletDynamics/ConstraintSolver/btFixedConstraint.h", "BulletDynamics/ConstraintSolver/btGearConstraint.h", @@ -51,11 +52,13 @@ "BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h", "BulletDynamics/ConstraintSolver/btHinge2Constraint.h", "BulletDynamics/ConstraintSolver/btHingeConstraint.h", + "BulletDynamics/ConstraintSolver/btJacobianEntry.h", "BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h", "BulletDynamics/ConstraintSolver/btPoint2PointConstraint.h", "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h", "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolverMt.h", "BulletDynamics/ConstraintSolver/btSliderConstraint.h", + "BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h", "BulletDynamics/ConstraintSolver/btSolverBody.h", "BulletDynamics/ConstraintSolver/btSolverConstraint.h", "BulletDynamics/Dynamics/btRigidBody.h", @@ -77,6 +80,7 @@ "BulletDynamics/Featherstone/btMultiBodySolverConstraint.h", "BulletDynamics/Featherstone/btMultiBodyFixedConstraint.h", "BulletDynamics/Featherstone/btMultiBodyGearConstraint.h", + "BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h", "BulletDynamics/Featherstone/btMultiBodyJointFeedback.h", "BulletDynamics/Featherstone/btMultiBodyJointLimitConstraint.h", "BulletDynamics/Featherstone/btMultiBodyJointMotor.h", @@ -86,10 +90,15 @@ "BulletDynamics/Featherstone/btMultiBodyPoint2Point.h", "BulletDynamics/Featherstone/btMultiBodySliderConstraint.h", "BulletDynamics/Featherstone/btMultiBodySphericalJointMotor.h", + "BulletDynamics/MLCPSolvers/btDantzigLCP.h", "BulletDynamics/MLCPSolvers/btDantzigSolver.h", + "BulletDynamics/MLCPSolvers/btLemkeAlgorithm.h", "BulletDynamics/MLCPSolvers/btLemkeSolver.h", "BulletDynamics/MLCPSolvers/btMLCPSolver.h", + "BulletDynamics/MLCPSolvers/btMLCPSolverInterface.h", "BulletDynamics/MLCPSolvers/btSolveProjectedGaussSeidel.h", + "BulletDynamics/Character/btCharacterControllerInterface.h", + "BulletDynamics/Character/btKinematicCharacterController.h", }, link = "BulletDynamics@.3.20" ) @@ -129,53 +138,53 @@ public void map(InfoMap infoMap) { "BT_BACKWARDS_COMPATIBLE_SERIALIZATION" ).define(true)) - .put(new Info("btAlignedObjectArray").pointerTypes("btRigidBodyArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("RangeArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btMultiBodyConstraintArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btMultiBodySolverConstraintArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btRigidBodyArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("JointParamsArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("IslandArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSolverAnalyticsDataArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSolverBodyArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSolverConstraintArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btTypedConstraintArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btWheelInfoArray")) + .put(new Info("btBatchedConstraints::Range").pointerTypes("btBatchedConstraints.Range")) + .put(new Info("btConstraintArray").pointerTypes("btSolverConstraintArray")) + .put(new Info("btMultiBodyConstraintArray").pointerTypes("btMultiBodySolverConstraintArray")) + .put(new Info("btSequentialImpulseConstraintSolverMt::JointParams").pointerTypes("btSequentialImpulseConstraintSolverMt.JointParams")) + .put(new Info("btSimulationIslandManagerMt::Island").pointerTypes("btSimulationIslandManagerMt.Island")) .put(new Info( - "DeformableBodyInplaceSolverIslandCallback", - "InplaceSolverIslandCallback", - "MultiBodyInplaceSolverIslandCallback", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", - "btBatchedConstraints::m_batches", - "btBatchedConstraints::m_phases", - "btConeTwistConstraint::solveConstraintObsolete", - "btConeTwistConstraintData::m_typeConstraintData", - "btConeTwistConstraintDoubleData::m_typeConstraintData", - "btConstraintArray", - "btConstraintInfo1", - "btConstraintInfo2", - "btGearConstraintDoubleData::m_typeConstraintData", - "btGearConstraintFloatData::m_typeConstraintData", - "btGeneric6DofConstraintData::m_typeConstraintData", - "btGeneric6DofConstraintDoubleData2::m_typeConstraintData", - "btGeneric6DofSpring2ConstraintData::m_typeConstraintData", - "btGeneric6DofSpring2ConstraintDoubleData2::m_typeConstraintData", - "btHingeConstraintDoubleData2::m_typeConstraintData", - "btHingeConstraintDoubleData::m_typeConstraintData", - "btHingeConstraintFloatData::m_typeConstraintData", - "btMultiBodyConstraint::createConstraintRows", - "btMultiBodyDynamicsWorld::getAnalyticsData", - "btMultiBodyJacobianData::m_solverBodyPool", - "btPoint2PointConstraintDoubleData2::m_typeConstraintData", - "btPoint2PointConstraintDoubleData::m_typeConstraintData", - "btPoint2PointConstraintFloatData::m_typeConstraintData", - "btRaycastVehicle::m_wheelInfo", - "btSequentialImpulseConstraintSolverMt::internalConvertMultipleJoints", - "btSimulationIslandManagerMt::Island::bodyArray", - "btSimulationIslandManagerMt::Island::constraintArray", - "btSimulationIslandManagerMt::Island::manifoldArray", - "btSimulationIslandManagerMt::IslandDispatchFunc", - "btSimulationIslandManagerMt::buildAndProcessIslands", - "btSimulationIslandManagerMt::parallelIslandDispatch", - "btSimulationIslandManagerMt::serialIslandDispatch", - "btSingleConstraintRowSolver", - "btSliderConstraintData::m_typeConstraintData", - "btSliderConstraintDoubleData::m_typeConstraintData", - "btSolverInfo" + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btDantzigScratchMemory::Arows" ).skip()) ; } From 2bc443ce726e4781e7131770f5b0c2dc33dc156b Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Fri, 11 Mar 2022 14:00:12 +0800 Subject: [PATCH 54/81] Update generated code of bullet preset See parent commit. --- .../InplaceSolverIslandCallback.java | 24 ++ .../bullet/BulletDynamics/IslandArray.java | 90 +++++ .../BulletDynamics/JointParamsArray.java | 90 +++++ .../MultiBodyInplaceSolverIslandCallback.java | 62 +++ .../bullet/BulletDynamics/RangeArray.java | 94 +++++ .../BulletDynamics/btBatchedConstraints.java | 11 +- .../btCharacterControllerInterface.java | 38 ++ .../BulletDynamics/btConeTwistConstraint.java | 10 +- .../btConeTwistConstraintData.java | 2 +- .../btConeTwistConstraintDoubleData.java | 2 +- .../BulletDynamics/btContactConstraint.java | 35 ++ .../btDantzigScratchMemory.java | 47 +++ .../BulletDynamics/btGearConstraint.java | 2 + .../btGearConstraintDoubleData.java | 2 +- .../btGearConstraintFloatData.java | 2 +- .../btGeneric6DofConstraint.java | 15 + .../btGeneric6DofConstraintData.java | 2 +- .../btGeneric6DofConstraintDoubleData2.java | 2 +- .../btGeneric6DofSpring2Constraint.java | 2 + .../btGeneric6DofSpring2ConstraintData.java | 2 +- ...neric6DofSpring2ConstraintDoubleData2.java | 2 +- .../btGeneric6DofSpringConstraint.java | 2 + .../btHingeAccumulatedAngleConstraint.java | 1 + .../BulletDynamics/btHingeConstraint.java | 11 + .../btHingeConstraintDoubleData.java | 2 +- .../btHingeConstraintDoubleData2.java | 2 +- .../btHingeConstraintFloatData.java | 2 +- .../BulletDynamics/btJacobianEntry.java | 117 ++++++ .../btKinematicCharacterController.java | 105 +++++ .../BulletDynamics/btLemkeAlgorithm.java | 51 +++ .../BulletDynamics/btMLCPSolverInterface.java | 10 +- .../BulletDynamics/btMultiBodyConstraint.java | 4 +- .../btMultiBodyConstraintArray.java | 90 +++++ .../btMultiBodyDynamicsWorld.java | 2 +- .../btMultiBodyFixedConstraint.java | 2 +- .../btMultiBodyGearConstraint.java | 2 +- .../btMultiBodyJacobianData.java | 2 +- .../btMultiBodyJointLimitConstraint.java | 2 +- .../BulletDynamics/btMultiBodyJointMotor.java | 2 +- .../btMultiBodyPoint2Point.java | 2 +- .../btMultiBodySliderConstraint.java | 2 +- .../btMultiBodySphericalJointMotor.java | 2 +- .../btPoint2PointConstraint.java | 8 + .../btPoint2PointConstraintDoubleData.java | 2 +- .../btPoint2PointConstraintDoubleData2.java | 2 +- .../btPoint2PointConstraintFloatData.java | 2 +- .../BulletDynamics/btRaycastVehicle.java | 2 +- .../BulletDynamics/btRigidBodyArray.java | 4 - .../btSequentialImpulseConstraintSolver.java | 11 + ...btSequentialImpulseConstraintSolverMt.java | 3 +- .../btSimulationIslandManagerMt.java | 26 +- .../btSingleConstraintRowSolver.java | 26 ++ .../BulletDynamics/btSliderConstraint.java | 8 + .../btSliderConstraintData.java | 2 +- .../btSliderConstraintDoubleData.java | 2 +- .../btSolve2LinearConstraint.java | 168 ++++++++ .../btSolverAnalyticsDataArray.java | 90 +++++ .../BulletDynamics/btSolverBodyArray.java | 90 +++++ .../btSolverConstraintArray.java | 90 +++++ .../bullet/BulletDynamics/btSolverInfo.java | 23 ++ .../btSortConstraintOnIslandPredicate2.java | 36 ++ ...tMultiBodyConstraintOnIslandPredicate.java | 37 ++ .../BulletDynamics/btTypedConstraint.java | 1 + .../btTypedConstraintArray.java | 90 +++++ .../BulletDynamics/btWheelInfoArray.java | 90 +++++ ...rmableBodyInplaceSolverIslandCallback.java | 25 ++ .../bullet/global/BulletDynamics.java | 378 +++++++++++++++++- .../bullet/global/BulletSoftBody.java | 3 + 68 files changed, 2122 insertions(+), 48 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/IslandArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/JointParamsArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/RangeArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btCharacterControllerInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDantzigScratchMemory.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJacobianEntry.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btKinematicCharacterController.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btLemkeAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSingleConstraintRowSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolve2LinearConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsDataArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBodyArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSortConstraintOnIslandPredicate2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSortMultiBodyConstraintOnIslandPredicate.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java new file mode 100644 index 00000000000..2914dd93683 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/InplaceSolverIslandCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class InplaceSolverIslandCallback extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public InplaceSolverIslandCallback() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public InplaceSolverIslandCallback(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/IslandArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/IslandArray.java new file mode 100644 index 00000000000..293d93dd9ef --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/IslandArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class IslandArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IslandArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public IslandArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public IslandArray position(long position) { + return (IslandArray)super.position(position); + } + @Override public IslandArray getPointer(long i) { + return new IslandArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") IslandArray put(@Const @ByRef IslandArray other); + public IslandArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public IslandArray(@Const @ByRef IslandArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef IslandArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btSimulationIslandManagerMt.Island at(int n); + + public native @ByPtrRef @Name("operator []") btSimulationIslandManagerMt.Island get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btSimulationIslandManagerMt.Island fillData/*=btSimulationIslandManagerMt::Island*()*/); + public native void resize(int newsize); + public native @ByPtrRef btSimulationIslandManagerMt.Island expandNonInitializing(); + + public native @ByPtrRef btSimulationIslandManagerMt.Island expand(@ByPtrRef btSimulationIslandManagerMt.Island fillValue/*=btSimulationIslandManagerMt::Island*()*/); + public native @ByPtrRef btSimulationIslandManagerMt.Island expand(); + + public native void push_back(@ByPtrRef btSimulationIslandManagerMt.Island _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btSimulationIslandManagerMt.Island key); + + public native int findLinearSearch(@ByPtrRef btSimulationIslandManagerMt.Island key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btSimulationIslandManagerMt.Island key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btSimulationIslandManagerMt.Island key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef IslandArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/JointParamsArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/JointParamsArray.java new file mode 100644 index 00000000000..cbb6ce603b0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/JointParamsArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class JointParamsArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public JointParamsArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public JointParamsArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public JointParamsArray position(long position) { + return (JointParamsArray)super.position(position); + } + @Override public JointParamsArray getPointer(long i) { + return new JointParamsArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") JointParamsArray put(@Const @ByRef JointParamsArray other); + public JointParamsArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public JointParamsArray(@Const @ByRef JointParamsArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef JointParamsArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSequentialImpulseConstraintSolverMt.JointParams at(int n); + + public native @ByRef @Name("operator []") btSequentialImpulseConstraintSolverMt.JointParams get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSequentialImpulseConstraintSolverMt::JointParams()") btSequentialImpulseConstraintSolverMt.JointParams fillData); + public native void resize(int newsize); + public native @ByRef btSequentialImpulseConstraintSolverMt.JointParams expandNonInitializing(); + + public native @ByRef btSequentialImpulseConstraintSolverMt.JointParams expand(@Const @ByRef(nullValue = "btSequentialImpulseConstraintSolverMt::JointParams()") btSequentialImpulseConstraintSolverMt.JointParams fillValue); + public native @ByRef btSequentialImpulseConstraintSolverMt.JointParams expand(); + + public native void push_back(@Const @ByRef btSequentialImpulseConstraintSolverMt.JointParams _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef JointParamsArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java new file mode 100644 index 00000000000..fcdab219926 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/MultiBodyInplaceSolverIslandCallback.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class MultiBodyInplaceSolverIslandCallback extends btSimulationIslandManager.IslandCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public MultiBodyInplaceSolverIslandCallback(Pointer p) { super(p); } + + + public native btContactSolverInfo m_solverInfo(); public native MultiBodyInplaceSolverIslandCallback m_solverInfo(btContactSolverInfo setter); + public native btMultiBodyConstraintSolver m_solver(); public native MultiBodyInplaceSolverIslandCallback m_solver(btMultiBodyConstraintSolver setter); + public native btMultiBodyConstraint m_multiBodySortedConstraints(int i); public native MultiBodyInplaceSolverIslandCallback m_multiBodySortedConstraints(int i, btMultiBodyConstraint setter); + public native @Cast("btMultiBodyConstraint**") PointerPointer m_multiBodySortedConstraints(); public native MultiBodyInplaceSolverIslandCallback m_multiBodySortedConstraints(PointerPointer setter); + public native int m_numMultiBodyConstraints(); public native MultiBodyInplaceSolverIslandCallback m_numMultiBodyConstraints(int setter); + + public native btTypedConstraint m_sortedConstraints(int i); public native MultiBodyInplaceSolverIslandCallback m_sortedConstraints(int i, btTypedConstraint setter); + public native @Cast("btTypedConstraint**") PointerPointer m_sortedConstraints(); public native MultiBodyInplaceSolverIslandCallback m_sortedConstraints(PointerPointer setter); + public native int m_numConstraints(); public native MultiBodyInplaceSolverIslandCallback m_numConstraints(int setter); + public native btIDebugDraw m_debugDrawer(); public native MultiBodyInplaceSolverIslandCallback m_debugDrawer(btIDebugDraw setter); + public native btDispatcher m_dispatcher(); public native MultiBodyInplaceSolverIslandCallback m_dispatcher(btDispatcher setter); + + public native @ByRef btCollisionObjectArray m_bodies(); public native MultiBodyInplaceSolverIslandCallback m_bodies(btCollisionObjectArray setter); + public native @ByRef btCollisionObjectArray m_softBodies(); public native MultiBodyInplaceSolverIslandCallback m_softBodies(btCollisionObjectArray setter); + public native @ByRef btPersistentManifoldArray m_manifolds(); public native MultiBodyInplaceSolverIslandCallback m_manifolds(btPersistentManifoldArray setter); + public native @ByRef btTypedConstraintArray m_constraints(); public native MultiBodyInplaceSolverIslandCallback m_constraints(btTypedConstraintArray setter); + public native @ByRef btMultiBodyConstraintArray m_multiBodyConstraints(); public native MultiBodyInplaceSolverIslandCallback m_multiBodyConstraints(btMultiBodyConstraintArray setter); + + public native @ByRef btSolverAnalyticsDataArray m_islandAnalyticsData(); public native MultiBodyInplaceSolverIslandCallback m_islandAnalyticsData(btSolverAnalyticsDataArray setter); + + public MultiBodyInplaceSolverIslandCallback(btMultiBodyConstraintSolver solver, + btDispatcher dispatcher) { super((Pointer)null); allocate(solver, dispatcher); } + private native void allocate(btMultiBodyConstraintSolver solver, + btDispatcher dispatcher); + + public native @ByRef @Name("operator =") MultiBodyInplaceSolverIslandCallback put(@Const @ByRef MultiBodyInplaceSolverIslandCallback other); + + public native void setup(btContactSolverInfo solverInfo, @Cast("btTypedConstraint**") PointerPointer sortedConstraints, int numConstraints, @Cast("btMultiBodyConstraint**") PointerPointer sortedMultiBodyConstraints, int numMultiBodyConstraints, btIDebugDraw debugDrawer); + public native void setup(btContactSolverInfo solverInfo, @ByPtrPtr btTypedConstraint sortedConstraints, int numConstraints, @ByPtrPtr btMultiBodyConstraint sortedMultiBodyConstraints, int numMultiBodyConstraints, btIDebugDraw debugDrawer); + + public native void setMultiBodyConstraintSolver(btMultiBodyConstraintSolver solver); + + public native void processIsland(@Cast("btCollisionObject**") PointerPointer bodies, int numBodies, @Cast("btPersistentManifold**") PointerPointer manifolds, int numManifolds, int islandId); + public native void processIsland(@ByPtrPtr btCollisionObject bodies, int numBodies, @ByPtrPtr btPersistentManifold manifolds, int numManifolds, int islandId); + + public native void processConstraints(int islandId/*=-1*/); + public native void processConstraints(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/RangeArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/RangeArray.java new file mode 100644 index 00000000000..f17f19efd3e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/RangeArray.java @@ -0,0 +1,94 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class RangeArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RangeArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public RangeArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public RangeArray position(long position) { + return (RangeArray)super.position(position); + } + @Override public RangeArray getPointer(long i) { + return new RangeArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") RangeArray put(@Const @ByRef RangeArray other); + public RangeArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public RangeArray(@Const @ByRef RangeArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef RangeArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btBatchedConstraints.Range at(int n); + + public native @ByRef @Name("operator []") btBatchedConstraints.Range get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btBatchedConstraints::Range()") btBatchedConstraints.Range fillData); + public native void resize(int newsize); + public native @ByRef btBatchedConstraints.Range expandNonInitializing(); + + public native @ByRef btBatchedConstraints.Range expand(@Const @ByRef(nullValue = "btBatchedConstraints::Range()") btBatchedConstraints.Range fillValue); + public native @ByRef btBatchedConstraints.Range expand(); + + public native void push_back(@Const @ByRef btBatchedConstraints.Range _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef RangeArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java index a92887876a2..4de1c55d10e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btBatchedConstraints.java @@ -59,8 +59,8 @@ public class btBatchedConstraints extends Pointer { } public native @ByRef btIntArray m_constraintIndices(); public native btBatchedConstraints m_constraintIndices(btIntArray setter); - // each batch is a range of indices in the m_constraintIndices array - // each phase is range of indices in the m_batches array + public native @ByRef RangeArray m_batches(); public native btBatchedConstraints m_batches(RangeArray setter); // each batch is a range of indices in the m_constraintIndices array + public native @ByRef RangeArray m_phases(); public native btBatchedConstraints m_phases(RangeArray setter); // each phase is range of indices in the m_batches array public native @ByRef btCharArray m_phaseGrainSize(); public native btBatchedConstraints m_phaseGrainSize(btCharArray setter); // max grain size for each phase public native @ByRef btIntArray m_phaseOrder(); public native btBatchedConstraints m_phaseOrder(btIntArray setter); // phases can be done in any order, so we can randomize the order here public native btIDebugDraw m_debugDrawer(); public native btBatchedConstraints m_debugDrawer(btIDebugDraw setter); @@ -69,4 +69,11 @@ public class btBatchedConstraints extends Pointer { public btBatchedConstraints() { super((Pointer)null); allocate(); } private native void allocate(); + public native void setup(btSolverConstraintArray constraints, + @Const @ByRef btSolverBodyArray bodies, + @Cast("btBatchedConstraints::BatchingMethod") int batchingMethod, + int minBatchSize, + int maxBatchSize, + btCharArray scratchMemory); + public native @Cast("bool") boolean validate(btSolverConstraintArray constraints, @Const @ByRef btSolverBodyArray bodies); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btCharacterControllerInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btCharacterControllerInterface.java new file mode 100644 index 00000000000..34f72a36b2a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btCharacterControllerInterface.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btCharacterControllerInterface extends btActionInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCharacterControllerInterface(Pointer p) { super(p); } + + + public native void setWalkDirection(@Const @ByRef btVector3 walkDirection); + public native void setVelocityForTimeInterval(@Const @ByRef btVector3 velocity, @Cast("btScalar") float timeInterval); + public native void reset(btCollisionWorld collisionWorld); + public native void warp(@Const @ByRef btVector3 origin); + + public native void preStep(btCollisionWorld collisionWorld); + public native void playerStep(btCollisionWorld collisionWorld, @Cast("btScalar") float dt); + public native @Cast("bool") boolean canJump(); + public native void jump(@Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 dir); + public native void jump(); + + public native @Cast("bool") boolean onGround(); + public native void setUpInterpolate(@Cast("bool") boolean value); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java index 00e50fbfcdb..dd096cc5eac 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraint.java @@ -31,7 +31,15 @@ public class btConeTwistConstraint extends btTypedConstraint { public native void buildJacobian(); - + public native void getInfo1(btConstraintInfo1 info); + + public native void getInfo1NonVirtual(btConstraintInfo1 info); + + public native void getInfo2(btConstraintInfo2 info); + + public native void getInfo2NonVirtual(btConstraintInfo2 info, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btMatrix3x3 invInertiaWorldA, @Const @ByRef btMatrix3x3 invInertiaWorldB); + + public native void solveConstraintObsolete(@ByRef btSolverBody bodyA, @ByRef btSolverBody bodyB, @Cast("btScalar") float timeStep); public native void updateRHS(@Cast("btScalar") float timeStep); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java index d71dc2d7cb1..cfb8b49dd84 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintData.java @@ -35,7 +35,7 @@ public class btConeTwistConstraintData extends Pointer { return new btConeTwistConstraintData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintData m_typeConstraintData(); public native btConeTwistConstraintData m_typeConstraintData(btTypedConstraintData setter); public native @ByRef btTransformFloatData m_rbAFrame(); public native btConeTwistConstraintData m_rbAFrame(btTransformFloatData setter); public native @ByRef btTransformFloatData m_rbBFrame(); public native btConeTwistConstraintData m_rbBFrame(btTransformFloatData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java index 88114fd0b2f..fb90dfc9f40 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btConeTwistConstraintDoubleData.java @@ -33,7 +33,7 @@ public class btConeTwistConstraintDoubleData extends Pointer { return new btConeTwistConstraintDoubleData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintDoubleData m_typeConstraintData(); public native btConeTwistConstraintDoubleData m_typeConstraintData(btTypedConstraintDoubleData setter); public native @ByRef btTransformDoubleData m_rbAFrame(); public native btConeTwistConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); public native @ByRef btTransformDoubleData m_rbBFrame(); public native btConeTwistConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactConstraint.java new file mode 100644 index 00000000000..a38cba56969 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btContactConstraint.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**btContactConstraint can be automatically created to solve contact constraints using the unified btTypedConstraint interface */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btContactConstraint extends btTypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btContactConstraint(Pointer p) { super(p); } + + public native void setContactManifold(btPersistentManifold contactManifold); + + public native btPersistentManifold getContactManifold(); + + public native void getInfo1(btConstraintInfo1 info); + + public native void getInfo2(btConstraintInfo2 info); + + /**obsolete methods */ + public native void buildJacobian(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDantzigScratchMemory.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDantzigScratchMemory.java new file mode 100644 index 00000000000..1e99b556574 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btDantzigScratchMemory.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btDantzigScratchMemory extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btDantzigScratchMemory() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDantzigScratchMemory(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDantzigScratchMemory(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btDantzigScratchMemory position(long position) { + return (btDantzigScratchMemory)super.position(position); + } + @Override public btDantzigScratchMemory getPointer(long i) { + return new btDantzigScratchMemory((Pointer)this).offsetAddress(i); + } + + public native @ByRef btScalarArray m_scratch(); public native btDantzigScratchMemory m_scratch(btScalarArray setter); + public native @ByRef btScalarArray L(); public native btDantzigScratchMemory L(btScalarArray setter); + public native @ByRef btScalarArray d(); public native btDantzigScratchMemory d(btScalarArray setter); + public native @ByRef btScalarArray delta_w(); public native btDantzigScratchMemory delta_w(btScalarArray setter); + public native @ByRef btScalarArray delta_x(); public native btDantzigScratchMemory delta_x(btScalarArray setter); + public native @ByRef btScalarArray Dell(); public native btDantzigScratchMemory Dell(btScalarArray setter); + public native @ByRef btScalarArray ell(); public native btDantzigScratchMemory ell(btScalarArray setter); + + public native @ByRef btIntArray p(); public native btDantzigScratchMemory p(btIntArray setter); + public native @ByRef btIntArray C(); public native btDantzigScratchMemory C(btIntArray setter); + public native @ByRef btBoolArray state(); public native btDantzigScratchMemory state(btBoolArray setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java index e0f30118333..c3da3f8d452 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraint.java @@ -30,8 +30,10 @@ public class btGearConstraint extends btTypedConstraint { private native void allocate(@ByRef btRigidBody rbA, @ByRef btRigidBody rbB, @Const @ByRef btVector3 axisInA, @Const @ByRef btVector3 axisInB); /**internal method used by the constraint solver, don't use them directly */ + public native void getInfo1(btConstraintInfo1 info); /**internal method used by the constraint solver, don't use them directly */ + public native void getInfo2(btConstraintInfo2 info); public native void setAxisA(@ByRef btVector3 axisA); public native void setAxisB(@ByRef btVector3 axisB); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java index c3af3208283..0c4338adcd4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintDoubleData.java @@ -33,7 +33,7 @@ public class btGearConstraintDoubleData extends Pointer { return new btGearConstraintDoubleData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintDoubleData m_typeConstraintData(); public native btGearConstraintDoubleData m_typeConstraintData(btTypedConstraintDoubleData setter); public native @ByRef btVector3DoubleData m_axisInA(); public native btGearConstraintDoubleData m_axisInA(btVector3DoubleData setter); public native @ByRef btVector3DoubleData m_axisInB(); public native btGearConstraintDoubleData m_axisInB(btVector3DoubleData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java index 8e7b42dc2ee..9cb43b74d4b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGearConstraintFloatData.java @@ -34,7 +34,7 @@ public class btGearConstraintFloatData extends Pointer { return new btGearConstraintFloatData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintFloatData m_typeConstraintData(); public native btGearConstraintFloatData m_typeConstraintData(btTypedConstraintFloatData setter); public native @ByRef btVector3FloatData m_axisInA(); public native btGearConstraintFloatData m_axisInA(btVector3FloatData setter); public native @ByRef btVector3FloatData m_axisInB(); public native btGearConstraintFloatData m_axisInB(btVector3FloatData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java index 13ffc8f91d3..bad72f49e7a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraint.java @@ -94,6 +94,14 @@ public class btGeneric6DofConstraint extends btTypedConstraint { /** performs Jacobian calculation, and also calculates angle differences and axis */ public native void buildJacobian(); + public native void getInfo1(btConstraintInfo1 info); + + public native void getInfo1NonVirtual(btConstraintInfo1 info); + + public native void getInfo2(btConstraintInfo2 info); + + public native void getInfo2NonVirtual(btConstraintInfo2 info, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btVector3 linVelA, @Const @ByRef btVector3 linVelB, @Const @ByRef btVector3 angVelA, @Const @ByRef btVector3 angVelB); + public native void updateRHS(@Cast("btScalar") float timeStep); /** Get the rotation axis in global coordinates @@ -159,6 +167,13 @@ public class btGeneric6DofConstraint extends btTypedConstraint { public native void calcAnchorPos(); // overridable + public native int get_limit_motor_info2(btRotationalLimitMotor limot, + @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btVector3 linVelA, @Const @ByRef btVector3 linVelB, @Const @ByRef btVector3 angVelA, @Const @ByRef btVector3 angVelB, + btConstraintInfo2 info, int row, @ByRef btVector3 ax1, int rotational, int rotAllowed/*=false*/); + public native int get_limit_motor_info2(btRotationalLimitMotor limot, + @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btVector3 linVelA, @Const @ByRef btVector3 linVelB, @Const @ByRef btVector3 angVelA, @Const @ByRef btVector3 angVelB, + btConstraintInfo2 info, int row, @ByRef btVector3 ax1, int rotational); + // access for UseFrameOffset public native @Cast("bool") boolean getUseFrameOffset(); public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java index b8243da6352..aad5e1daa80 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintData.java @@ -33,7 +33,7 @@ public class btGeneric6DofConstraintData extends Pointer { return new btGeneric6DofConstraintData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintData m_typeConstraintData(); public native btGeneric6DofConstraintData m_typeConstraintData(btTypedConstraintData setter); public native @ByRef btTransformFloatData m_rbAFrame(); public native btGeneric6DofConstraintData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. public native @ByRef btTransformFloatData m_rbBFrame(); public native btGeneric6DofConstraintData m_rbBFrame(btTransformFloatData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java index 99e962eed4d..b4e1c7b1c6f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofConstraintDoubleData2.java @@ -33,7 +33,7 @@ public class btGeneric6DofConstraintDoubleData2 extends Pointer { return new btGeneric6DofConstraintDoubleData2((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintDoubleData m_typeConstraintData(); public native btGeneric6DofConstraintDoubleData2 m_typeConstraintData(btTypedConstraintDoubleData setter); public native @ByRef btTransformDoubleData m_rbAFrame(); public native btGeneric6DofConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. public native @ByRef btTransformDoubleData m_rbBFrame(); public native btGeneric6DofConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java index 4f7bc231e17..fb0b4188c03 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2Constraint.java @@ -32,6 +32,8 @@ public class btGeneric6DofSpring2Constraint extends btTypedConstraint { private native void allocate(@ByRef btRigidBody rbB, @Const @ByRef btTransform frameInB); public native void buildJacobian(); + public native void getInfo1(btConstraintInfo1 info); + public native void getInfo2(btConstraintInfo2 info); public native int calculateSerializeBufferSize(); public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java index 8928a01e1a1..f100e9c092a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintData.java @@ -33,7 +33,7 @@ public class btGeneric6DofSpring2ConstraintData extends Pointer { return new btGeneric6DofSpring2ConstraintData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintData m_typeConstraintData(); public native btGeneric6DofSpring2ConstraintData m_typeConstraintData(btTypedConstraintData setter); public native @ByRef btTransformFloatData m_rbAFrame(); public native btGeneric6DofSpring2ConstraintData m_rbAFrame(btTransformFloatData setter); public native @ByRef btTransformFloatData m_rbBFrame(); public native btGeneric6DofSpring2ConstraintData m_rbBFrame(btTransformFloatData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java index c46e3799c46..c0d66074a29 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpring2ConstraintDoubleData2.java @@ -33,7 +33,7 @@ public class btGeneric6DofSpring2ConstraintDoubleData2 extends Pointer { return new btGeneric6DofSpring2ConstraintDoubleData2((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintDoubleData m_typeConstraintData(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_typeConstraintData(btTypedConstraintDoubleData setter); public native @ByRef btTransformDoubleData m_rbAFrame(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); public native @ByRef btTransformDoubleData m_rbBFrame(); public native btGeneric6DofSpring2ConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java index 60b35a38c8b..330c9b2116c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btGeneric6DofSpringConstraint.java @@ -54,6 +54,8 @@ public class btGeneric6DofSpringConstraint extends btGeneric6DofConstraint { public native void setAxis(@Const @ByRef btVector3 axis1, @Const @ByRef btVector3 axis2); + public native void getInfo2(btConstraintInfo2 info); + public native int calculateSerializeBufferSize(); /**fills the dataBuffer and returns the struct name (and 0 on failure) */ public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, btSerializer serializer); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java index 9f9bf82d705..d46f6e189e5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeAccumulatedAngleConstraint.java @@ -45,4 +45,5 @@ public class btHingeAccumulatedAngleConstraint extends btHingeConstraint { private native void allocate(@ByRef btRigidBody rbA, @Const @ByRef btTransform rbAFrame); public native @Cast("btScalar") float getAccumulatedHingeAngle(); public native void setAccumulatedHingeAngle(@Cast("btScalar") float accAngle); + public native void getInfo1(btConstraintInfo1 info); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java index 56dff587c17..46ad2cb291e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraint.java @@ -46,6 +46,17 @@ public class btHingeConstraint extends btTypedConstraint { public native void buildJacobian(); + public native void getInfo1(btConstraintInfo1 info); + + public native void getInfo1NonVirtual(btConstraintInfo1 info); + + public native void getInfo2(btConstraintInfo2 info); + + public native void getInfo2NonVirtual(btConstraintInfo2 info, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btVector3 angVelA, @Const @ByRef btVector3 angVelB); + + public native void getInfo2Internal(btConstraintInfo2 info, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btVector3 angVelA, @Const @ByRef btVector3 angVelB); + public native void getInfo2InternalUsingFrameOffset(btConstraintInfo2 info, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btVector3 angVelA, @Const @ByRef btVector3 angVelB); + public native void updateRHS(@Cast("btScalar") float timeStep); public native @ByRef btRigidBody getRigidBodyA(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java index a7498233ab7..5b91115d326 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData.java @@ -36,7 +36,7 @@ public class btHingeConstraintDoubleData extends Pointer { return new btHingeConstraintDoubleData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintData m_typeConstraintData(); public native btHingeConstraintDoubleData m_typeConstraintData(btTypedConstraintData setter); public native @ByRef btTransformDoubleData m_rbAFrame(); public native btHingeConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. public native @ByRef btTransformDoubleData m_rbBFrame(); public native btHingeConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); public native int m_useReferenceFrameA(); public native btHingeConstraintDoubleData m_useReferenceFrameA(int setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java index 7be4cba1149..72d085650e1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintDoubleData2.java @@ -34,7 +34,7 @@ public class btHingeConstraintDoubleData2 extends Pointer { return new btHingeConstraintDoubleData2((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintDoubleData m_typeConstraintData(); public native btHingeConstraintDoubleData2 m_typeConstraintData(btTypedConstraintDoubleData setter); public native @ByRef btTransformDoubleData m_rbAFrame(); public native btHingeConstraintDoubleData2 m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. public native @ByRef btTransformDoubleData m_rbBFrame(); public native btHingeConstraintDoubleData2 m_rbBFrame(btTransformDoubleData setter); public native int m_useReferenceFrameA(); public native btHingeConstraintDoubleData2 m_useReferenceFrameA(int setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java index 75ab8ba5aff..2a78fe3a8a3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btHingeConstraintFloatData.java @@ -33,7 +33,7 @@ public class btHingeConstraintFloatData extends Pointer { return new btHingeConstraintFloatData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintData m_typeConstraintData(); public native btHingeConstraintFloatData m_typeConstraintData(btTypedConstraintData setter); public native @ByRef btTransformFloatData m_rbAFrame(); public native btHingeConstraintFloatData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. public native @ByRef btTransformFloatData m_rbBFrame(); public native btHingeConstraintFloatData m_rbBFrame(btTransformFloatData setter); public native int m_useReferenceFrameA(); public native btHingeConstraintFloatData m_useReferenceFrameA(int setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJacobianEntry.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJacobianEntry.java new file mode 100644 index 00000000000..57ac79017f9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btJacobianEntry.java @@ -0,0 +1,117 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +//notes: +// Another memory optimization would be to store m_1MinvJt in the remaining 3 w components +// which makes the btJacobianEntry memory layout 16 bytes +// if you only are interested in angular part, just feed massInvA and massInvB zero + +/** Jacobian entry is an abstraction that allows to describe constraints + * it can be used in combination with a constraint solver + * Can be used to relate the effect of an impulse to the constraint error */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btJacobianEntry extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btJacobianEntry(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btJacobianEntry(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btJacobianEntry position(long position) { + return (btJacobianEntry)super.position(position); + } + @Override public btJacobianEntry getPointer(long i) { + return new btJacobianEntry((Pointer)this).offsetAddress(i); + } + + public btJacobianEntry() { super((Pointer)null); allocate(); } + private native void allocate(); + //constraint between two different rigidbodies + public btJacobianEntry( + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + @Const @ByRef btVector3 rel_pos1, @Const @ByRef btVector3 rel_pos2, + @Const @ByRef btVector3 jointAxis, + @Const @ByRef btVector3 inertiaInvA, + @Cast("const btScalar") float massInvA, + @Const @ByRef btVector3 inertiaInvB, + @Cast("const btScalar") float massInvB) { super((Pointer)null); allocate(world2A, world2B, rel_pos1, rel_pos2, jointAxis, inertiaInvA, massInvA, inertiaInvB, massInvB); } + private native void allocate( + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + @Const @ByRef btVector3 rel_pos1, @Const @ByRef btVector3 rel_pos2, + @Const @ByRef btVector3 jointAxis, + @Const @ByRef btVector3 inertiaInvA, + @Cast("const btScalar") float massInvA, + @Const @ByRef btVector3 inertiaInvB, + @Cast("const btScalar") float massInvB); + + //angular constraint between two different rigidbodies + public btJacobianEntry(@Const @ByRef btVector3 jointAxis, + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + @Const @ByRef btVector3 inertiaInvA, + @Const @ByRef btVector3 inertiaInvB) { super((Pointer)null); allocate(jointAxis, world2A, world2B, inertiaInvA, inertiaInvB); } + private native void allocate(@Const @ByRef btVector3 jointAxis, + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + @Const @ByRef btVector3 inertiaInvA, + @Const @ByRef btVector3 inertiaInvB); + + //angular constraint between two different rigidbodies + public btJacobianEntry(@Const @ByRef btVector3 axisInA, + @Const @ByRef btVector3 axisInB, + @Const @ByRef btVector3 inertiaInvA, + @Const @ByRef btVector3 inertiaInvB) { super((Pointer)null); allocate(axisInA, axisInB, inertiaInvA, inertiaInvB); } + private native void allocate(@Const @ByRef btVector3 axisInA, + @Const @ByRef btVector3 axisInB, + @Const @ByRef btVector3 inertiaInvA, + @Const @ByRef btVector3 inertiaInvB); + + //constraint on one rigidbody + public btJacobianEntry( + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btVector3 rel_pos1, @Const @ByRef btVector3 rel_pos2, + @Const @ByRef btVector3 jointAxis, + @Const @ByRef btVector3 inertiaInvA, + @Cast("const btScalar") float massInvA) { super((Pointer)null); allocate(world2A, rel_pos1, rel_pos2, jointAxis, inertiaInvA, massInvA); } + private native void allocate( + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btVector3 rel_pos1, @Const @ByRef btVector3 rel_pos2, + @Const @ByRef btVector3 jointAxis, + @Const @ByRef btVector3 inertiaInvA, + @Cast("const btScalar") float massInvA); + + public native @Cast("btScalar") float getDiagonal(); + + // for two constraints on the same rigidbody (for example vehicle friction) + public native @Cast("btScalar") float getNonDiagonal(@Const @ByRef btJacobianEntry jacB, @Cast("const btScalar") float massInvA); + + // for two constraints on sharing two same rigidbodies (for example two contact points between two rigidbodies) + public native @Cast("btScalar") float getNonDiagonal(@Const @ByRef btJacobianEntry jacB, @Cast("const btScalar") float massInvA, @Cast("const btScalar") float massInvB); + + public native @Cast("btScalar") float getRelativeVelocity(@Const @ByRef btVector3 linvelA, @Const @ByRef btVector3 angvelA, @Const @ByRef btVector3 linvelB, @Const @ByRef btVector3 angvelB); + //private: + + public native @ByRef btVector3 m_linearJointAxis(); public native btJacobianEntry m_linearJointAxis(btVector3 setter); + public native @ByRef btVector3 m_aJ(); public native btJacobianEntry m_aJ(btVector3 setter); + public native @ByRef btVector3 m_bJ(); public native btJacobianEntry m_bJ(btVector3 setter); + public native @ByRef btVector3 m_0MinvJt(); public native btJacobianEntry m_0MinvJt(btVector3 setter); + public native @ByRef btVector3 m_1MinvJt(); public native btJacobianEntry m_1MinvJt(btVector3 setter); + //Optimization: can be stored in the w/last component of one of the vectors + public native @Cast("btScalar") float m_Adiag(); public native btJacobianEntry m_Adiag(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btKinematicCharacterController.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btKinematicCharacterController.java new file mode 100644 index 00000000000..5c648ac4446 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btKinematicCharacterController.java @@ -0,0 +1,105 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/**btKinematicCharacterController is an object that supports a sliding motion in a world. + * It uses a ghost object and convex sweep test to test for upcoming collisions. This is combined with discrete collision detection to recover from penetrations. + * Interaction between btKinematicCharacterController and dynamic rigid bodies needs to be explicity implemented by the user. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btKinematicCharacterController extends btCharacterControllerInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btKinematicCharacterController(Pointer p) { super(p); } + + + public btKinematicCharacterController(btPairCachingGhostObject ghostObject, btConvexShape convexShape, @Cast("btScalar") float stepHeight, @Const @ByRef(nullValue = "btVector3(1.0, 0.0, 0.0)") btVector3 up) { super((Pointer)null); allocate(ghostObject, convexShape, stepHeight, up); } + private native void allocate(btPairCachingGhostObject ghostObject, btConvexShape convexShape, @Cast("btScalar") float stepHeight, @Const @ByRef(nullValue = "btVector3(1.0, 0.0, 0.0)") btVector3 up); + public btKinematicCharacterController(btPairCachingGhostObject ghostObject, btConvexShape convexShape, @Cast("btScalar") float stepHeight) { super((Pointer)null); allocate(ghostObject, convexShape, stepHeight); } + private native void allocate(btPairCachingGhostObject ghostObject, btConvexShape convexShape, @Cast("btScalar") float stepHeight); + + /**btActionInterface interface */ + public native void updateAction(btCollisionWorld collisionWorld, @Cast("btScalar") float deltaTime); + + /**btActionInterface interface */ + public native void debugDraw(btIDebugDraw debugDrawer); + + public native void setUp(@Const @ByRef btVector3 up); + + public native @Const @ByRef btVector3 getUp(); + + /** This should probably be called setPositionIncrementPerSimulatorStep. + * This is neither a direction nor a velocity, but the amount to + * increment the position each simulation iteration, regardless + * of dt. + * This call will reset any velocity set by setVelocityForTimeInterval(). */ + public native void setWalkDirection(@Const @ByRef btVector3 walkDirection); + + /** Caller provides a velocity with which the character should move for + * the given time period. After the time period, velocity is reset + * to zero. + * This call will reset any walk direction set by setWalkDirection(). + * Negative time intervals will result in no motion. */ + public native void setVelocityForTimeInterval(@Const @ByRef btVector3 velocity, + @Cast("btScalar") float timeInterval); + + public native void setAngularVelocity(@Const @ByRef btVector3 velocity); + public native @Const @ByRef btVector3 getAngularVelocity(); + + public native void setLinearVelocity(@Const @ByRef btVector3 velocity); + public native @ByVal btVector3 getLinearVelocity(); + + public native void setLinearDamping(@Cast("btScalar") float d); + public native @Cast("btScalar") float getLinearDamping(); + public native void setAngularDamping(@Cast("btScalar") float d); + public native @Cast("btScalar") float getAngularDamping(); + + public native void reset(btCollisionWorld collisionWorld); + public native void warp(@Const @ByRef btVector3 origin); + + public native void preStep(btCollisionWorld collisionWorld); + public native void playerStep(btCollisionWorld collisionWorld, @Cast("btScalar") float dt); + + public native void setStepHeight(@Cast("btScalar") float h); + public native @Cast("btScalar") float getStepHeight(); + public native void setFallSpeed(@Cast("btScalar") float fallSpeed); + public native @Cast("btScalar") float getFallSpeed(); + public native void setJumpSpeed(@Cast("btScalar") float jumpSpeed); + public native @Cast("btScalar") float getJumpSpeed(); + public native void setMaxJumpHeight(@Cast("btScalar") float maxJumpHeight); + public native @Cast("bool") boolean canJump(); + + public native void jump(@Const @ByRef(nullValue = "btVector3(0, 0, 0)") btVector3 v); + public native void jump(); + + public native void applyImpulse(@Const @ByRef btVector3 v); + + public native void setGravity(@Const @ByRef btVector3 gravity); + public native @ByVal btVector3 getGravity(); + + /** The max slope determines the maximum angle that the controller can walk up. + * The slope angle is measured in radians. */ + public native void setMaxSlope(@Cast("btScalar") float slopeRadians); + public native @Cast("btScalar") float getMaxSlope(); + + public native void setMaxPenetrationDepth(@Cast("btScalar") float d); + public native @Cast("btScalar") float getMaxPenetrationDepth(); + + public native btPairCachingGhostObject getGhostObject(); + public native void setUseGhostSweepTest(@Cast("bool") boolean useGhostObjectSweepTest); + + public native @Cast("bool") boolean onGround(); + public native void setUpInterpolate(@Cast("bool") boolean value); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btLemkeAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btLemkeAlgorithm.java new file mode 100644 index 00000000000..095d2e871f6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btLemkeAlgorithm.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + //todo: replace by btAlignedObjectArray + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btLemkeAlgorithm extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btLemkeAlgorithm(Pointer p) { super(p); } + + public btLemkeAlgorithm(@Const @ByRef btMatrixXf M_, @Const @ByRef btVectorXf q_, int DEBUGLEVEL_/*=0*/) { super((Pointer)null); allocate(M_, q_, DEBUGLEVEL_); } + private native void allocate(@Const @ByRef btMatrixXf M_, @Const @ByRef btVectorXf q_, int DEBUGLEVEL_/*=0*/); + public btLemkeAlgorithm(@Const @ByRef btMatrixXf M_, @Const @ByRef btVectorXf q_) { super((Pointer)null); allocate(M_, q_); } + private native void allocate(@Const @ByRef btMatrixXf M_, @Const @ByRef btVectorXf q_); + + /* GETTER / SETTER */ + /** + * \brief return info of solution process + */ + public native int getInfo(); + + /** + * \brief get the number of steps until the solution was found + */ + public native int getSteps(); + + /** + * \brief set system with Matrix M and vector q + */ + public native void setSystem(@Const @ByRef btMatrixXf M_, @Const @ByRef btVectorXf q_); + /***************************************************/ + + /** + * \brief solve algorithm adapted from : Fast Implementation of Lemke’s Algorithm for Rigid Body Contact Simulation (John E. Lloyd) + */ + public native @ByVal btVectorXf solve(@Cast("unsigned int") int maxloops/*=0*/); + public native @ByVal btVectorXf solve(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolverInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolverInterface.java index 7630baea581..d5bfb3b8f9d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolverInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMLCPSolverInterface.java @@ -15,10 +15,14 @@ import static org.bytedeco.bullet.global.BulletDynamics.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) public class btMLCPSolverInterface extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public btMLCPSolverInterface() { super((Pointer)null); } + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btMLCPSolverInterface(Pointer p) { super(p); } + + + //return true is it solves the problem successfully + public native @Cast("bool") boolean solveMLCP(@Const @ByRef btMatrixXf A, @Const @ByRef btVectorXf b, @ByRef btVectorXf x, @Const @ByRef btVectorXf lo, @Const @ByRef btVectorXf hi, @Const @ByRef btIntArray limitDependency, int numIterations, @Cast("bool") boolean useSparsity/*=true*/); + public native @Cast("bool") boolean solveMLCP(@Const @ByRef btMatrixXf A, @Const @ByRef btVectorXf b, @ByRef btVectorXf x, @Const @ByRef btVectorXf lo, @Const @ByRef btVectorXf hi, @Const @ByRef btIntArray limitDependency, int numIterations); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java index de36707dd5e..77ec8b7530e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraint.java @@ -35,7 +35,9 @@ public class btMultiBodyConstraint extends Pointer { public native int getIslandIdA(); public native int getIslandIdB(); - + public native void createConstraintRows(@ByRef btMultiBodySolverConstraintArray constraintRows, + @ByRef btMultiBodyJacobianData data, + @Const @ByRef btContactSolverInfo infoGlobal); public native int getNumRows(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintArray.java new file mode 100644 index 00000000000..9f927dd1203 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyConstraintArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btMultiBodyConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btMultiBodyConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btMultiBodyConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btMultiBodyConstraintArray position(long position) { + return (btMultiBodyConstraintArray)super.position(position); + } + @Override public btMultiBodyConstraintArray getPointer(long i) { + return new btMultiBodyConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btMultiBodyConstraintArray put(@Const @ByRef btMultiBodyConstraintArray other); + public btMultiBodyConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btMultiBodyConstraintArray(@Const @ByRef btMultiBodyConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btMultiBodyConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btMultiBodyConstraint at(int n); + + public native @ByPtrRef @Name("operator []") btMultiBodyConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btMultiBodyConstraint fillData/*=btMultiBodyConstraint*()*/); + public native void resize(int newsize); + public native @ByPtrRef btMultiBodyConstraint expandNonInitializing(); + + public native @ByPtrRef btMultiBodyConstraint expand(@ByPtrRef btMultiBodyConstraint fillValue/*=btMultiBodyConstraint*()*/); + public native @ByPtrRef btMultiBodyConstraint expand(); + + public native void push_back(@ByPtrRef btMultiBodyConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btMultiBodyConstraint key); + + public native int findLinearSearch(@ByPtrRef btMultiBodyConstraint key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btMultiBodyConstraint key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btMultiBodyConstraint key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btMultiBodyConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java index 925678e79b7..9c889764a1c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyDynamicsWorld.java @@ -63,7 +63,7 @@ public class btMultiBodyDynamicsWorld extends btDiscreteDynamicsWorld { public native void serialize(btSerializer serializer); public native void setMultiBodyConstraintSolver(btMultiBodyConstraintSolver solver); public native void setConstraintSolver(btConstraintSolver solver); - + public native void getAnalyticsData(@ByRef btSolverAnalyticsDataArray m_islandAnalyticsData); public native void solveExternalForces(@ByRef btContactSolverInfo solverInfo); public native void solveInternalConstraints(@ByRef btContactSolverInfo solverInfo); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFixedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFixedConstraint.java index 6e19d92b45f..31a5593859f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFixedConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyFixedConstraint.java @@ -31,7 +31,7 @@ public class btMultiBodyFixedConstraint extends btMultiBodyConstraint { public native int getIslandIdA(); public native int getIslandIdB(); - public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + public native void createConstraintRows(@ByRef btMultiBodySolverConstraintArray constraintRows, @ByRef btMultiBodyJacobianData data, @Const @ByRef btContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyGearConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyGearConstraint.java index ec598f6707d..508f252f07e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyGearConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyGearConstraint.java @@ -30,7 +30,7 @@ public class btMultiBodyGearConstraint extends btMultiBodyConstraint { public native int getIslandIdA(); public native int getIslandIdB(); - public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + public native void createConstraintRows(@ByRef btMultiBodySolverConstraintArray constraintRows, @ByRef btMultiBodyJacobianData data, @Const @ByRef btContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java index 4de49719f6d..3930a30e8d1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJacobianData.java @@ -39,6 +39,6 @@ public class btMultiBodyJacobianData extends Pointer { public native @ByRef btScalarArray scratch_r(); public native btMultiBodyJacobianData scratch_r(btScalarArray setter); public native @ByRef btVector3Array scratch_v(); public native btMultiBodyJacobianData scratch_v(btVector3Array setter); public native @ByRef btMatrix3x3Array scratch_m(); public native btMultiBodyJacobianData scratch_m(btMatrix3x3Array setter); - + public native btSolverBodyArray m_solverBodyPool(); public native btMultiBodyJacobianData m_solverBodyPool(btSolverBodyArray setter); public native int m_fixedBodyId(); public native btMultiBodyJacobianData m_fixedBodyId(int setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointLimitConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointLimitConstraint.java index f84523a3abc..b97c586b4cd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointLimitConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointLimitConstraint.java @@ -29,7 +29,7 @@ public class btMultiBodyJointLimitConstraint extends btMultiBodyConstraint { public native int getIslandIdA(); public native int getIslandIdB(); - public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + public native void createConstraintRows(@ByRef btMultiBodySolverConstraintArray constraintRows, @ByRef btMultiBodyJacobianData data, @Const @ByRef btContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointMotor.java index 8234f34f082..16e6c834dc8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointMotor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyJointMotor.java @@ -30,7 +30,7 @@ public class btMultiBodyJointMotor extends btMultiBodyConstraint { public native int getIslandIdA(); public native int getIslandIdB(); - public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + public native void createConstraintRows(@ByRef btMultiBodySolverConstraintArray constraintRows, @ByRef btMultiBodyJacobianData data, @Const @ByRef btContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyPoint2Point.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyPoint2Point.java index 44ceb633a87..0f96f706ea8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyPoint2Point.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodyPoint2Point.java @@ -34,7 +34,7 @@ public class btMultiBodyPoint2Point extends btMultiBodyConstraint { public native int getIslandIdA(); public native int getIslandIdB(); - public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + public native void createConstraintRows(@ByRef btMultiBodySolverConstraintArray constraintRows, @ByRef btMultiBodyJacobianData data, @Const @ByRef btContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySliderConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySliderConstraint.java index c6d4dc8c07b..110b7b033c9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySliderConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySliderConstraint.java @@ -31,7 +31,7 @@ public class btMultiBodySliderConstraint extends btMultiBodyConstraint { public native int getIslandIdA(); public native int getIslandIdB(); - public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + public native void createConstraintRows(@ByRef btMultiBodySolverConstraintArray constraintRows, @ByRef btMultiBodyJacobianData data, @Const @ByRef btContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySphericalJointMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySphericalJointMotor.java index 82571bcd9a0..20d35c560ca 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySphericalJointMotor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btMultiBodySphericalJointMotor.java @@ -28,7 +28,7 @@ public class btMultiBodySphericalJointMotor extends btMultiBodyConstraint { public native int getIslandIdA(); public native int getIslandIdB(); - public native void createConstraintRows(@Cast("btMultiBodyConstraintArray*") @ByRef btMultiBodySolverConstraintArray constraintRows, + public native void createConstraintRows(@ByRef btMultiBodySolverConstraintArray constraintRows, @ByRef btMultiBodyJacobianData data, @Const @ByRef btContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java index 275cf6d19e0..1fba4862e7d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraint.java @@ -36,6 +36,14 @@ public class btPoint2PointConstraint extends btTypedConstraint { public native void buildJacobian(); + public native void getInfo1(btConstraintInfo1 info); + + public native void getInfo1NonVirtual(btConstraintInfo1 info); + + public native void getInfo2(btConstraintInfo2 info); + + public native void getInfo2NonVirtual(btConstraintInfo2 info, @Const @ByRef btTransform body0_trans, @Const @ByRef btTransform body1_trans); + public native void updateRHS(@Cast("btScalar") float timeStep); public native void setPivotA(@Const @ByRef btVector3 pivotA); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java index 2b7b297ed29..3290e3c9ee6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData.java @@ -37,7 +37,7 @@ public class btPoint2PointConstraintDoubleData extends Pointer { return new btPoint2PointConstraintDoubleData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintData m_typeConstraintData(); public native btPoint2PointConstraintDoubleData m_typeConstraintData(btTypedConstraintData setter); public native @ByRef btVector3DoubleData m_pivotInA(); public native btPoint2PointConstraintDoubleData m_pivotInA(btVector3DoubleData setter); public native @ByRef btVector3DoubleData m_pivotInB(); public native btPoint2PointConstraintDoubleData m_pivotInB(btVector3DoubleData setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java index 1715c80adf7..83fc2c332d8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintDoubleData2.java @@ -34,7 +34,7 @@ public class btPoint2PointConstraintDoubleData2 extends Pointer { return new btPoint2PointConstraintDoubleData2((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintDoubleData m_typeConstraintData(); public native btPoint2PointConstraintDoubleData2 m_typeConstraintData(btTypedConstraintDoubleData setter); public native @ByRef btVector3DoubleData m_pivotInA(); public native btPoint2PointConstraintDoubleData2 m_pivotInA(btVector3DoubleData setter); public native @ByRef btVector3DoubleData m_pivotInB(); public native btPoint2PointConstraintDoubleData2 m_pivotInB(btVector3DoubleData setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java index a14e91762a7..76101101fd3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btPoint2PointConstraintFloatData.java @@ -34,7 +34,7 @@ public class btPoint2PointConstraintFloatData extends Pointer { return new btPoint2PointConstraintFloatData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintData m_typeConstraintData(); public native btPoint2PointConstraintFloatData m_typeConstraintData(btTypedConstraintData setter); public native @ByRef btVector3FloatData m_pivotInA(); public native btPoint2PointConstraintFloatData m_pivotInA(btVector3FloatData setter); public native @ByRef btVector3FloatData m_pivotInB(); public native btPoint2PointConstraintFloatData m_pivotInB(btVector3FloatData setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java index 9a93f8f39f4..46f5a26937c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRaycastVehicle.java @@ -82,7 +82,7 @@ public class btRaycastVehicle extends btActionInterface { public native int getNumWheels(); - + public native @ByRef btWheelInfoArray m_wheelInfo(); public native btRaycastVehicle m_wheelInfo(btWheelInfoArray setter); public native @ByRef btWheelInfo getWheelInfo(int index); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyArray.java index 9ecfcd1341f..a85c6d65db5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btRigidBodyArray.java @@ -13,11 +13,7 @@ import static org.bytedeco.bullet.global.BulletCollision.*; import static org.bytedeco.bullet.global.BulletDynamics.*; - //for placement new -// #endif //BT_USE_PLACEMENT_NEW -/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) public class btRigidBodyArray extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java index ddc6f2bf3b6..1741d639c27 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java @@ -50,10 +50,21 @@ public class btSequentialImpulseConstraintSolver extends btConstraintSolver { public native @Cast("btConstraintSolverType") int getSolverType(); + public native btSingleConstraintRowSolver getActiveConstraintRowSolverGeneric(); + public native void setConstraintRowSolverGeneric(btSingleConstraintRowSolver rowSolver); + public native btSingleConstraintRowSolver getActiveConstraintRowSolverLowerLimit(); + public native void setConstraintRowSolverLowerLimit(btSingleConstraintRowSolver rowSolver); + /**Various implementations of solving a single constraint row using a generic equality constraint, using scalar reference, SSE2 or SSE4 */ + public native btSingleConstraintRowSolver getScalarConstraintRowSolverGeneric(); + public native btSingleConstraintRowSolver getSSE2ConstraintRowSolverGeneric(); + public native btSingleConstraintRowSolver getSSE4_1ConstraintRowSolverGeneric(); /**Various implementations of solving a single constraint row using an inequality (lower limit) constraint, using scalar reference, SSE2 or SSE4 */ + public native btSingleConstraintRowSolver getScalarConstraintRowSolverLowerLimit(); + public native btSingleConstraintRowSolver getSSE2ConstraintRowSolverLowerLimit(); + public native btSingleConstraintRowSolver getSSE4_1ConstraintRowSolverLowerLimit(); public native @ByRef btSolverAnalyticsData m_analyticsData(); public native btSequentialImpulseConstraintSolver m_analyticsData(btSolverAnalyticsData setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java index 56161a0ab23..3428a0e2ec5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolverMt.java @@ -127,7 +127,8 @@ public static class JointParams extends Pointer { } public native void internalInitMultipleJoints(@Cast("btTypedConstraint**") PointerPointer constraints, int iBegin, int iEnd); public native void internalInitMultipleJoints(@ByPtrPtr btTypedConstraint constraints, int iBegin, int iEnd); - + public native void internalConvertMultipleJoints(@Const @ByRef JointParamsArray jointParamsArray, @Cast("btTypedConstraint**") PointerPointer constraints, int iBegin, int iEnd, @Const @ByRef btContactSolverInfo infoGlobal); + public native void internalConvertMultipleJoints(@Const @ByRef JointParamsArray jointParamsArray, @ByPtrPtr btTypedConstraint constraints, int iBegin, int iEnd, @Const @ByRef btContactSolverInfo infoGlobal); // parameters to control batching public static native @Cast("bool") boolean s_allowNestedParallelForLoops(); public static native void s_allowNestedParallelForLoops(boolean setter); // whether to allow nested parallel operations diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java index 81bf9e92a04..01ebe482bb5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSimulationIslandManagerMt.java @@ -58,9 +58,9 @@ public static class Island extends Pointer { // a simulation island consisting of bodies, manifolds and constraints, // to be passed into a constraint solver. - - - + public native @ByRef btCollisionObjectArray bodyArray(); public native Island bodyArray(btCollisionObjectArray setter); + public native @ByRef btPersistentManifoldArray manifoldArray(); public native Island manifoldArray(btPersistentManifoldArray setter); + public native @ByRef btTypedConstraintArray constraintArray(); public native Island constraintArray(btTypedConstraintArray setter); public native int id(); public native Island id(int setter); // island id public native @Cast("bool") boolean isSleeping(); public native Island isSleeping(boolean setter); @@ -90,16 +90,30 @@ public static class SolverParams extends Pointer { public native btDispatcher m_dispatcher(); public native SolverParams m_dispatcher(btDispatcher setter); } public static native void solveIsland(btConstraintSolver solver, @ByRef Island island, @Const @ByRef SolverParams solverParams); - - + + public static class IslandDispatchFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IslandDispatchFunc(Pointer p) { super(p); } + protected IslandDispatchFunc() { allocate(); } + private native void allocate(); + public native void call(IslandArray islands, @Const @ByRef SolverParams solverParams); + } + public static native void serialIslandDispatch(IslandArray islandsPtr, @Const @ByRef SolverParams solverParams); + public static native void parallelIslandDispatch(IslandArray islandsPtr, @Const @ByRef SolverParams solverParams); public btSimulationIslandManagerMt() { super((Pointer)null); allocate(); } private native void allocate(); - + public native void buildAndProcessIslands(btDispatcher dispatcher, + btCollisionWorld collisionWorld, + @ByRef btTypedConstraintArray constraints, + @Const @ByRef SolverParams solverParams); public native void buildIslands(btDispatcher dispatcher, btCollisionWorld colWorld); public native int getMinimumSolverBatchSize(); public native void setMinimumSolverBatchSize(int sz); + public native IslandDispatchFunc getIslandDispatchFunction(); // allow users to set their own dispatch function for multithreaded dispatch + public native void setIslandDispatchFunction(IslandDispatchFunc func); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSingleConstraintRowSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSingleConstraintRowSolver.java new file mode 100644 index 00000000000..ffefe9a5068 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSingleConstraintRowSolver.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSingleConstraintRowSolver extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSingleConstraintRowSolver(Pointer p) { super(p); } + protected btSingleConstraintRowSolver() { allocate(); } + private native void allocate(); + public native @Cast("btScalar") float call(@ByRef btSolverBody arg0, @ByRef btSolverBody arg1, @Const @ByRef btSolverConstraint arg2); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java index 1855cab94e0..99e0f355ebd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraint.java @@ -30,6 +30,14 @@ public class btSliderConstraint extends btTypedConstraint { // overrides + public native void getInfo1(btConstraintInfo1 info); + + public native void getInfo1NonVirtual(btConstraintInfo1 info); + + public native void getInfo2(btConstraintInfo2 info); + + public native void getInfo2NonVirtual(btConstraintInfo2 info, @Const @ByRef btTransform transA, @Const @ByRef btTransform transB, @Const @ByRef btVector3 linVelA, @Const @ByRef btVector3 linVelB, @Cast("btScalar") float rbAinvMass, @Cast("btScalar") float rbBinvMass); + // access public native @Const @ByRef btRigidBody getRigidBodyA(); public native @Const @ByRef btRigidBody getRigidBodyB(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java index b2a789a690d..ac3a6dddd73 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintData.java @@ -35,7 +35,7 @@ public class btSliderConstraintData extends Pointer { return new btSliderConstraintData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintData m_typeConstraintData(); public native btSliderConstraintData m_typeConstraintData(btTypedConstraintData setter); public native @ByRef btTransformFloatData m_rbAFrame(); public native btSliderConstraintData m_rbAFrame(btTransformFloatData setter); // constraint axii. Assumes z is hinge axis. public native @ByRef btTransformFloatData m_rbBFrame(); public native btSliderConstraintData m_rbBFrame(btTransformFloatData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java index 444d18dbbf6..542c68d707a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSliderConstraintDoubleData.java @@ -33,7 +33,7 @@ public class btSliderConstraintDoubleData extends Pointer { return new btSliderConstraintDoubleData((Pointer)this).offsetAddress(i); } - + public native @ByRef btTypedConstraintDoubleData m_typeConstraintData(); public native btSliderConstraintDoubleData m_typeConstraintData(btTypedConstraintDoubleData setter); public native @ByRef btTransformDoubleData m_rbAFrame(); public native btSliderConstraintDoubleData m_rbAFrame(btTransformDoubleData setter); // constraint axii. Assumes z is hinge axis. public native @ByRef btTransformDoubleData m_rbBFrame(); public native btSliderConstraintDoubleData m_rbBFrame(btTransformDoubleData setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolve2LinearConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolve2LinearConstraint.java new file mode 100644 index 00000000000..beed22e1607 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolve2LinearConstraint.java @@ -0,0 +1,168 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +/** constraint class used for lateral tyre friction. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolve2LinearConstraint extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolve2LinearConstraint(Pointer p) { super(p); } + + public btSolve2LinearConstraint(@Cast("btScalar") float tau, @Cast("btScalar") float damping) { super((Pointer)null); allocate(tau, damping); } + private native void allocate(@Cast("btScalar") float tau, @Cast("btScalar") float damping); + // + // solve unilateral constraint (equality, direct method) + // + public native void resolveUnilateralPairConstraint( + btRigidBody body0, + btRigidBody body1, + + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + + @Const @ByRef btVector3 invInertiaADiag, + @Cast("const btScalar") float invMassA, + @Const @ByRef btVector3 linvelA, @Const @ByRef btVector3 angvelA, + @Const @ByRef btVector3 rel_posA1, + @Const @ByRef btVector3 invInertiaBDiag, + @Cast("const btScalar") float invMassB, + @Const @ByRef btVector3 linvelB, @Const @ByRef btVector3 angvelB, + @Const @ByRef btVector3 rel_posA2, + + @Cast("btScalar") float depthA, @Const @ByRef btVector3 normalA, + @Const @ByRef btVector3 rel_posB1, @Const @ByRef btVector3 rel_posB2, + @Cast("btScalar") float depthB, @Const @ByRef btVector3 normalB, + @Cast("btScalar*") @ByRef FloatPointer imp0, @Cast("btScalar*") @ByRef FloatPointer imp1); + public native void resolveUnilateralPairConstraint( + btRigidBody body0, + btRigidBody body1, + + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + + @Const @ByRef btVector3 invInertiaADiag, + @Cast("const btScalar") float invMassA, + @Const @ByRef btVector3 linvelA, @Const @ByRef btVector3 angvelA, + @Const @ByRef btVector3 rel_posA1, + @Const @ByRef btVector3 invInertiaBDiag, + @Cast("const btScalar") float invMassB, + @Const @ByRef btVector3 linvelB, @Const @ByRef btVector3 angvelB, + @Const @ByRef btVector3 rel_posA2, + + @Cast("btScalar") float depthA, @Const @ByRef btVector3 normalA, + @Const @ByRef btVector3 rel_posB1, @Const @ByRef btVector3 rel_posB2, + @Cast("btScalar") float depthB, @Const @ByRef btVector3 normalB, + @Cast("btScalar*") @ByRef FloatBuffer imp0, @Cast("btScalar*") @ByRef FloatBuffer imp1); + public native void resolveUnilateralPairConstraint( + btRigidBody body0, + btRigidBody body1, + + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + + @Const @ByRef btVector3 invInertiaADiag, + @Cast("const btScalar") float invMassA, + @Const @ByRef btVector3 linvelA, @Const @ByRef btVector3 angvelA, + @Const @ByRef btVector3 rel_posA1, + @Const @ByRef btVector3 invInertiaBDiag, + @Cast("const btScalar") float invMassB, + @Const @ByRef btVector3 linvelB, @Const @ByRef btVector3 angvelB, + @Const @ByRef btVector3 rel_posA2, + + @Cast("btScalar") float depthA, @Const @ByRef btVector3 normalA, + @Const @ByRef btVector3 rel_posB1, @Const @ByRef btVector3 rel_posB2, + @Cast("btScalar") float depthB, @Const @ByRef btVector3 normalB, + @Cast("btScalar*") @ByRef float[] imp0, @Cast("btScalar*") @ByRef float[] imp1); + + // + // solving 2x2 lcp problem (inequality, direct solution ) + // + public native void resolveBilateralPairConstraint( + btRigidBody body0, + btRigidBody body1, + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + + @Const @ByRef btVector3 invInertiaADiag, + @Cast("const btScalar") float invMassA, + @Const @ByRef btVector3 linvelA, @Const @ByRef btVector3 angvelA, + @Const @ByRef btVector3 rel_posA1, + @Const @ByRef btVector3 invInertiaBDiag, + @Cast("const btScalar") float invMassB, + @Const @ByRef btVector3 linvelB, @Const @ByRef btVector3 angvelB, + @Const @ByRef btVector3 rel_posA2, + + @Cast("btScalar") float depthA, @Const @ByRef btVector3 normalA, + @Const @ByRef btVector3 rel_posB1, @Const @ByRef btVector3 rel_posB2, + @Cast("btScalar") float depthB, @Const @ByRef btVector3 normalB, + @Cast("btScalar*") @ByRef FloatPointer imp0, @Cast("btScalar*") @ByRef FloatPointer imp1); + public native void resolveBilateralPairConstraint( + btRigidBody body0, + btRigidBody body1, + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + + @Const @ByRef btVector3 invInertiaADiag, + @Cast("const btScalar") float invMassA, + @Const @ByRef btVector3 linvelA, @Const @ByRef btVector3 angvelA, + @Const @ByRef btVector3 rel_posA1, + @Const @ByRef btVector3 invInertiaBDiag, + @Cast("const btScalar") float invMassB, + @Const @ByRef btVector3 linvelB, @Const @ByRef btVector3 angvelB, + @Const @ByRef btVector3 rel_posA2, + + @Cast("btScalar") float depthA, @Const @ByRef btVector3 normalA, + @Const @ByRef btVector3 rel_posB1, @Const @ByRef btVector3 rel_posB2, + @Cast("btScalar") float depthB, @Const @ByRef btVector3 normalB, + @Cast("btScalar*") @ByRef FloatBuffer imp0, @Cast("btScalar*") @ByRef FloatBuffer imp1); + public native void resolveBilateralPairConstraint( + btRigidBody body0, + btRigidBody body1, + @Const @ByRef btMatrix3x3 world2A, + @Const @ByRef btMatrix3x3 world2B, + + @Const @ByRef btVector3 invInertiaADiag, + @Cast("const btScalar") float invMassA, + @Const @ByRef btVector3 linvelA, @Const @ByRef btVector3 angvelA, + @Const @ByRef btVector3 rel_posA1, + @Const @ByRef btVector3 invInertiaBDiag, + @Cast("const btScalar") float invMassB, + @Const @ByRef btVector3 linvelB, @Const @ByRef btVector3 angvelB, + @Const @ByRef btVector3 rel_posA2, + + @Cast("btScalar") float depthA, @Const @ByRef btVector3 normalA, + @Const @ByRef btVector3 rel_posB1, @Const @ByRef btVector3 rel_posB2, + @Cast("btScalar") float depthB, @Const @ByRef btVector3 normalB, + @Cast("btScalar*") @ByRef float[] imp0, @Cast("btScalar*") @ByRef float[] imp1); + + /* + void resolveAngularConstraint( const btMatrix3x3& invInertiaAWS, + const btScalar invMassA, + const btVector3& linvelA,const btVector3& angvelA, + const btVector3& rel_posA1, + const btMatrix3x3& invInertiaBWS, + const btScalar invMassB, + const btVector3& linvelB,const btVector3& angvelB, + const btVector3& rel_posA2, + + btScalar depthA, const btVector3& normalA, + const btVector3& rel_posB1,const btVector3& rel_posB2, + btScalar depthB, const btVector3& normalB, + btScalar& imp0,btScalar& imp1); + +*/ +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsDataArray.java new file mode 100644 index 00000000000..1fe71c72573 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverAnalyticsDataArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolverAnalyticsDataArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverAnalyticsDataArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSolverAnalyticsDataArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSolverAnalyticsDataArray position(long position) { + return (btSolverAnalyticsDataArray)super.position(position); + } + @Override public btSolverAnalyticsDataArray getPointer(long i) { + return new btSolverAnalyticsDataArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSolverAnalyticsDataArray put(@Const @ByRef btSolverAnalyticsDataArray other); + public btSolverAnalyticsDataArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSolverAnalyticsDataArray(@Const @ByRef btSolverAnalyticsDataArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSolverAnalyticsDataArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSolverAnalyticsData at(int n); + + public native @ByRef @Name("operator []") btSolverAnalyticsData get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSolverAnalyticsData()") btSolverAnalyticsData fillData); + public native void resize(int newsize); + public native @ByRef btSolverAnalyticsData expandNonInitializing(); + + public native @ByRef btSolverAnalyticsData expand(@Const @ByRef(nullValue = "btSolverAnalyticsData()") btSolverAnalyticsData fillValue); + public native @ByRef btSolverAnalyticsData expand(); + + public native void push_back(@Const @ByRef btSolverAnalyticsData _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSolverAnalyticsDataArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBodyArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBodyArray.java new file mode 100644 index 00000000000..c6c1de131d5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverBodyArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolverBodyArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverBodyArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSolverBodyArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSolverBodyArray position(long position) { + return (btSolverBodyArray)super.position(position); + } + @Override public btSolverBodyArray getPointer(long i) { + return new btSolverBodyArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSolverBodyArray put(@Const @ByRef btSolverBodyArray other); + public btSolverBodyArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSolverBodyArray(@Const @ByRef btSolverBodyArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSolverBodyArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSolverBody at(int n); + + public native @ByRef @Name("operator []") btSolverBody get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSolverBody()") btSolverBody fillData); + public native void resize(int newsize); + public native @ByRef btSolverBody expandNonInitializing(); + + public native @ByRef btSolverBody expand(@Const @ByRef(nullValue = "btSolverBody()") btSolverBody fillValue); + public native @ByRef btSolverBody expand(); + + public native void push_back(@Const @ByRef btSolverBody _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSolverBodyArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraintArray.java new file mode 100644 index 00000000000..afafd328c16 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverConstraintArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolverConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSolverConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSolverConstraintArray position(long position) { + return (btSolverConstraintArray)super.position(position); + } + @Override public btSolverConstraintArray getPointer(long i) { + return new btSolverConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSolverConstraintArray put(@Const @ByRef btSolverConstraintArray other); + public btSolverConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSolverConstraintArray(@Const @ByRef btSolverConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSolverConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSolverConstraint at(int n); + + public native @ByRef @Name("operator []") btSolverConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSolverConstraint()") btSolverConstraint fillData); + public native void resize(int newsize); + public native @ByRef btSolverConstraint expandNonInitializing(); + + public native @ByRef btSolverConstraint expand(@Const @ByRef(nullValue = "btSolverConstraint()") btSolverConstraint fillValue); + public native @ByRef btSolverConstraint expand(); + + public native void push_back(@Const @ByRef btSolverConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSolverConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java new file mode 100644 index 00000000000..bf2ca497038 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSolverInfo.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSolverInfo extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSolverInfo() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverInfo(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSortConstraintOnIslandPredicate2.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSortConstraintOnIslandPredicate2.java new file mode 100644 index 00000000000..27d046c0cf6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSortConstraintOnIslandPredicate2.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSortConstraintOnIslandPredicate2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSortConstraintOnIslandPredicate2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSortConstraintOnIslandPredicate2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSortConstraintOnIslandPredicate2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSortConstraintOnIslandPredicate2 position(long position) { + return (btSortConstraintOnIslandPredicate2)super.position(position); + } + @Override public btSortConstraintOnIslandPredicate2 getPointer(long i) { + return new btSortConstraintOnIslandPredicate2((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") @Name("operator ()") boolean apply(@Const btTypedConstraint lhs, @Const btTypedConstraint rhs); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSortMultiBodyConstraintOnIslandPredicate.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSortMultiBodyConstraintOnIslandPredicate.java new file mode 100644 index 00000000000..886e30af0dc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSortMultiBodyConstraintOnIslandPredicate.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btSortMultiBodyConstraintOnIslandPredicate extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSortMultiBodyConstraintOnIslandPredicate() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSortMultiBodyConstraintOnIslandPredicate(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSortMultiBodyConstraintOnIslandPredicate(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSortMultiBodyConstraintOnIslandPredicate position(long position) { + return (btSortMultiBodyConstraintOnIslandPredicate)super.position(position); + } + @Override public btSortMultiBodyConstraintOnIslandPredicate getPointer(long i) { + return new btSortMultiBodyConstraintOnIslandPredicate((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") @Name("operator ()") boolean apply(@Const btMultiBodyConstraint lhs, @Const btMultiBodyConstraint rhs); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java index 329ddf46919..6571dbf8242 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraint.java @@ -107,6 +107,7 @@ public static class btConstraintInfo2 extends Pointer { public native void buildJacobian(); /**internal method used by the constraint solver, don't use them directly */ + public native void setupSolverConstraint(@ByRef btSolverConstraintArray ca, int solverBodyA, int solverBodyB, @Cast("btScalar") float timeStep); /**internal method used by the constraint solver, don't use them directly */ public native void getInfo1(btConstraintInfo1 info); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintArray.java new file mode 100644 index 00000000000..2e025db98de --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btTypedConstraintArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btTypedConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTypedConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btTypedConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btTypedConstraintArray position(long position) { + return (btTypedConstraintArray)super.position(position); + } + @Override public btTypedConstraintArray getPointer(long i) { + return new btTypedConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btTypedConstraintArray put(@Const @ByRef btTypedConstraintArray other); + public btTypedConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btTypedConstraintArray(@Const @ByRef btTypedConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btTypedConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btTypedConstraint at(int n); + + public native @ByPtrRef @Name("operator []") btTypedConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btTypedConstraint fillData/*=btTypedConstraint*()*/); + public native void resize(int newsize); + public native @ByPtrRef btTypedConstraint expandNonInitializing(); + + public native @ByPtrRef btTypedConstraint expand(@ByPtrRef btTypedConstraint fillValue/*=btTypedConstraint*()*/); + public native @ByPtrRef btTypedConstraint expand(); + + public native void push_back(@ByPtrRef btTypedConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btTypedConstraint key); + + public native int findLinearSearch(@ByPtrRef btTypedConstraint key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btTypedConstraint key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btTypedConstraint key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btTypedConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoArray.java new file mode 100644 index 00000000000..5dd55dcffde --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btWheelInfoArray.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletDynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; + +import static org.bytedeco.bullet.global.BulletDynamics.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletDynamics.class) +public class btWheelInfoArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btWheelInfoArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btWheelInfoArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btWheelInfoArray position(long position) { + return (btWheelInfoArray)super.position(position); + } + @Override public btWheelInfoArray getPointer(long i) { + return new btWheelInfoArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btWheelInfoArray put(@Const @ByRef btWheelInfoArray other); + public btWheelInfoArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btWheelInfoArray(@Const @ByRef btWheelInfoArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btWheelInfoArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btWheelInfo at(int n); + + public native @ByRef @Name("operator []") btWheelInfo get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btWheelInfo()") btWheelInfo fillData); + public native void resize(int newsize); + public native @ByRef btWheelInfo expandNonInitializing(); + + public native @ByRef btWheelInfo expand(@Const @ByRef(nullValue = "btWheelInfo()") btWheelInfo fillValue); + public native @ByRef btWheelInfo expand(); + + public native void push_back(@Const @ByRef btWheelInfo _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btWheelInfoArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java new file mode 100644 index 00000000000..10804c8f9eb --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class DeformableBodyInplaceSolverIslandCallback extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public DeformableBodyInplaceSolverIslandCallback() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DeformableBodyInplaceSolverIslandCallback(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java index 35078b36f57..b323a9a8d0b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletDynamics.java @@ -57,12 +57,39 @@ public class BulletDynamics extends org.bytedeco.bullet.presets.BulletDynamics { // #ifdef BT_USE_PLACEMENT_NEW // #include -// Targeting ../BulletDynamics/btRigidBodyArray.java +// Targeting ../BulletDynamics/RangeArray.java + + +// Targeting ../BulletDynamics/btMultiBodyConstraintArray.java // Targeting ../BulletDynamics/btMultiBodySolverConstraintArray.java +// Targeting ../BulletDynamics/btRigidBodyArray.java + + +// Targeting ../BulletDynamics/JointParamsArray.java + + +// Targeting ../BulletDynamics/IslandArray.java + + +// Targeting ../BulletDynamics/btSolverAnalyticsDataArray.java + + +// Targeting ../BulletDynamics/btSolverBodyArray.java + + +// Targeting ../BulletDynamics/btSolverConstraintArray.java + + +// Targeting ../BulletDynamics/btTypedConstraintArray.java + + +// Targeting ../BulletDynamics/btWheelInfoArray.java + + // #endif //BT_OBJECT_ARRAY__ @@ -206,6 +233,51 @@ btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc // #endif //BT_CONSTRAINT_SOLVER_H +// Parsed from BulletDynamics/ConstraintSolver/btContactConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CONTACT_CONSTRAINT_H +// #define BT_CONTACT_CONSTRAINT_H + +// #include "LinearMath/btVector3.h" +// #include "btJacobianEntry.h" +// #include "btTypedConstraint.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// Targeting ../BulletDynamics/btContactConstraint.java + + + +/**very basic collision resolution without friction */ +public static native @Cast("btScalar") float resolveSingleCollision(btRigidBody body1, btCollisionObject colObj2, @Const @ByRef btVector3 contactPositionWorld, @Const @ByRef btVector3 contactNormalOnB, @Const @ByRef btContactSolverInfo solverInfo, @Cast("btScalar") float distance); + +/**resolveSingleBilateral is an obsolete methods used for vehicle friction between two dynamic objects */ +public static native void resolveSingleBilateral(@ByRef btRigidBody body1, @Const @ByRef btVector3 pos1, + @ByRef btRigidBody body2, @Const @ByRef btVector3 pos2, + @Cast("btScalar") float distance, @Const @ByRef btVector3 normal, @Cast("btScalar*") @ByRef FloatPointer impulse, @Cast("btScalar") float timeStep); +public static native void resolveSingleBilateral(@ByRef btRigidBody body1, @Const @ByRef btVector3 pos1, + @ByRef btRigidBody body2, @Const @ByRef btVector3 pos2, + @Cast("btScalar") float distance, @Const @ByRef btVector3 normal, @Cast("btScalar*") @ByRef FloatBuffer impulse, @Cast("btScalar") float timeStep); +public static native void resolveSingleBilateral(@ByRef btRigidBody body1, @Const @ByRef btVector3 pos1, + @ByRef btRigidBody body2, @Const @ByRef btVector3 pos2, + @Cast("btScalar") float distance, @Const @ByRef btVector3 normal, @Cast("btScalar*") @ByRef float[] impulse, @Cast("btScalar") float timeStep); + +// #endif //BT_CONTACT_CONSTRAINT_H + + // Parsed from BulletDynamics/ConstraintSolver/btContactSolverInfo.h /* @@ -633,6 +705,34 @@ btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc // #endif //BT_HINGECONSTRAINT_H +// Parsed from BulletDynamics/ConstraintSolver/btJacobianEntry.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_JACOBIAN_ENTRY_H +// #define BT_JACOBIAN_ENTRY_H + +// #include "LinearMath/btMatrix3x3.h" +// Targeting ../BulletDynamics/btJacobianEntry.java + + + +// #endif //BT_JACOBIAN_ENTRY_H + + // Parsed from BulletDynamics/ConstraintSolver/btNNCGConstraintSolver.h /* @@ -744,6 +844,9 @@ btConeTwistConstraint can be used to simulate ragdoll joints (upper arm, leg etc // #include "BulletDynamics/ConstraintSolver/btSolverConstraint.h" // #include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h" // #include "BulletDynamics/ConstraintSolver/btConstraintSolver.h" +// Targeting ../BulletDynamics/btSingleConstraintRowSolver.java + + // Targeting ../BulletDynamics/btSolverAnalyticsData.java @@ -875,6 +978,35 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_SLIDER_CONSTRAINT_H +// Parsed from BulletDynamics/ConstraintSolver/btSolve2LinearConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOLVE_2LINEAR_CONSTRAINT_H +// #define BT_SOLVE_2LINEAR_CONSTRAINT_H + +// #include "LinearMath/btMatrix3x3.h" +// #include "LinearMath/btVector3.h" +// Targeting ../BulletDynamics/btSolve2LinearConstraint.java + + + +// #endif //BT_SOLVE_2LINEAR_CONSTRAINT_H + + // Parsed from BulletDynamics/ConstraintSolver/btSolverBody.h /* @@ -1225,6 +1357,9 @@ Added by Roman Ponomarev (rponom@gmail.com) // #define BT_DISCRETE_DYNAMICS_WORLD_H // #include "btDynamicsWorld.h" +// Targeting ../BulletDynamics/InplaceSolverIslandCallback.java + + // #include "LinearMath/btAlignedObjectArray.h" // #include "LinearMath/btThreads.h" @@ -1510,6 +1645,9 @@ Added by Roman Ponomarev (rponom@gmail.com) MULTIBODY_CONSTRAINT_FIXED = 9, MAX_MULTIBODY_CONSTRAINT_TYPE = 10; +// Targeting ../BulletDynamics/btSolverInfo.java + + // #include "btMultiBodySolverConstraint.h" // Targeting ../BulletDynamics/btMultiBodyJacobianData.java @@ -1676,6 +1814,46 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_MULTIBODY_GEAR_CONSTRAINT_H +// Parsed from BulletDynamics/Featherstone/btMultiBodyInplaceSolverIslandCallback.h + +/* + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_MULTIBODY_INPLACE_SOLVER_ISLAND_CALLBACK_H +// #define BT_MULTIBODY_INPLACE_SOLVER_ISLAND_CALLBACK_H + +// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" +// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" +// #include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h" +// #include "btMultiBodyConstraintSolver.h" + +public static native int btGetConstraintIslandId2(@Const btTypedConstraint lhs); +// Targeting ../BulletDynamics/btSortConstraintOnIslandPredicate2.java + + + +public static native int btGetMultiBodyConstraintIslandId(@Const btMultiBodyConstraint lhs); +// Targeting ../BulletDynamics/btSortMultiBodyConstraintOnIslandPredicate.java + + +// Targeting ../BulletDynamics/MultiBodyInplaceSolverIslandCallback.java + + + + +// #endif /*BT_MULTIBODY_INPLACE_SOLVER_ISLAND_CALLBACK_H */ + + // Parsed from BulletDynamics/Featherstone/btMultiBodyJointFeedback.h /* @@ -1879,9 +2057,6 @@ Added by Roman Ponomarev (rponom@gmail.com) // #include "LinearMath/btMatrixX.h" // #include "LinearMath/btThreads.h" // #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" -// Targeting ../BulletDynamics/btMLCPSolverInterface.java - - // Targeting ../BulletDynamics/btMultiBodyMLCPConstraintSolver.java @@ -1979,6 +2154,75 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_MULTIBODY_SPHERICAL_JOINT_MOTOR_H +// Parsed from BulletDynamics/MLCPSolvers/btDantzigLCP.h + +/************************************************************************* + * * + * Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith. * + * All rights reserved. Email: russ\q12.org Web: www.q12.org * + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of * + * The BSD-style license that is included with this library in * + * the file LICENSE-BSD.TXT. * + * * + * This library is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files * + * LICENSE.TXT and LICENSE-BSD.TXT for more details. * + * * + *************************************************************************/ + +/* + +given (A,b,lo,hi), solve the LCP problem: A*x = b+w, where each x(i),w(i) +satisfies one of + (1) x = lo, w >= 0 + (2) x = hi, w <= 0 + (3) lo < x < hi, w = 0 +A is a matrix of dimension n*n, everything else is a vector of size n*1. +lo and hi can be +/- dInfinity as needed. the first `nub' variables are +unbounded, i.e. hi and lo are assumed to be +/- dInfinity. + +we restrict lo(i) <= 0 and hi(i) >= 0. + +the original data (A,b) may be modified by this function. + +if the `findex' (friction index) parameter is nonzero, it points to an array +of index values. in this case constraints that have findex[i] >= 0 are +special. all non-special constraints are solved for, then the lo and hi values +for the special constraints are set: + hi[i] = abs( hi[i] * x[findex[i]] ) + lo[i] = -hi[i] +and the solution continues. this mechanism allows a friction approximation +to be implemented. the first `nub' variables are assumed to have findex < 0. + +*/ + +// #ifndef _BT_LCP_H_ +// #define _BT_LCP_H_ + +// #include +// #include +// #include + +// #include "LinearMath/btScalar.h" +// #include "LinearMath/btAlignedObjectArray.h" +// Targeting ../BulletDynamics/btDantzigScratchMemory.java + + + +//return false if solving failed +public static native @Cast("bool") boolean btSolveDantzigLCP(int n, @Cast("btScalar*") FloatPointer A, @Cast("btScalar*") FloatPointer x, @Cast("btScalar*") FloatPointer b, @Cast("btScalar*") FloatPointer w, + int nub, @Cast("btScalar*") FloatPointer lo, @Cast("btScalar*") FloatPointer hi, IntPointer findex, @ByRef btDantzigScratchMemory scratch); +public static native @Cast("bool") boolean btSolveDantzigLCP(int n, @Cast("btScalar*") FloatBuffer A, @Cast("btScalar*") FloatBuffer x, @Cast("btScalar*") FloatBuffer b, @Cast("btScalar*") FloatBuffer w, + int nub, @Cast("btScalar*") FloatBuffer lo, @Cast("btScalar*") FloatBuffer hi, IntBuffer findex, @ByRef btDantzigScratchMemory scratch); +public static native @Cast("bool") boolean btSolveDantzigLCP(int n, @Cast("btScalar*") float[] A, @Cast("btScalar*") float[] x, @Cast("btScalar*") float[] b, @Cast("btScalar*") float[] w, + int nub, @Cast("btScalar*") float[] lo, @Cast("btScalar*") float[] hi, int[] findex, @ByRef btDantzigScratchMemory scratch); + +// #endif //_BT_LCP_H_ + + // Parsed from BulletDynamics/MLCPSolvers/btDantzigSolver.h /* @@ -2009,6 +2253,42 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_DANTZIG_SOLVER_H +// Parsed from BulletDynamics/MLCPSolvers/btLemkeAlgorithm.h + +/* Copyright (C) 2004-2013 MBSim Development Team + +Code was converted for the Bullet Continuous Collision Detection and Physics Library + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +//The original version is here +//https://code.google.com/p/mbsim-env/source/browse/trunk/kernel/mbsim/numerics/linear_complementarity_problem/lemke_algorithm.cc +//This file is re-distributed under the ZLib license, with permission of the original author (Kilian Grundl) +//Math library was replaced from fmatvec to a the file src/LinearMath/btMatrixX.h +//STL/std::vector replaced by btAlignedObjectArray + +// #ifndef BT_NUMERICS_LEMKE_ALGORITHM_H_ +// #define BT_NUMERICS_LEMKE_ALGORITHM_H_ + +// #include "LinearMath/btMatrixX.h" + +// #include +// Targeting ../BulletDynamics/btLemkeAlgorithm.java + + + +// #endif /* BT_NUMERICS_LEMKE_ALGORITHM_H_ */ + + // Parsed from BulletDynamics/MLCPSolvers/btLemkeSolver.h /* @@ -2070,6 +2350,35 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_MLCP_SOLVER_H +// Parsed from BulletDynamics/MLCPSolvers/btMLCPSolverInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**original version written by Erwin Coumans, October 2013 */ + +// #ifndef BT_MLCP_SOLVER_INTERFACE_H +// #define BT_MLCP_SOLVER_INTERFACE_H + +// #include "LinearMath/btMatrixX.h" +// Targeting ../BulletDynamics/btMLCPSolverInterface.java + + + +// #endif //BT_MLCP_SOLVER_INTERFACE_H + + // Parsed from BulletDynamics/MLCPSolvers/btSolveProjectedGaussSeidel.h /* @@ -2099,4 +2408,65 @@ Added by Roman Ponomarev (rponom@gmail.com) // #endif //BT_SOLVE_PROJECTED_GAUSS_SEIDEL_H +// Parsed from BulletDynamics/Character/btCharacterControllerInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_CHARACTER_CONTROLLER_INTERFACE_H +// #define BT_CHARACTER_CONTROLLER_INTERFACE_H + +// #include "LinearMath/btVector3.h" +// #include "BulletDynamics/Dynamics/btActionInterface.h" +// Targeting ../BulletDynamics/btCharacterControllerInterface.java + + + +// #endif //BT_CHARACTER_CONTROLLER_INTERFACE_H + + +// Parsed from BulletDynamics/Character/btKinematicCharacterController.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_KINEMATIC_CHARACTER_CONTROLLER_H +// #define BT_KINEMATIC_CHARACTER_CONTROLLER_H + +// #include "LinearMath/btVector3.h" + +// #include "btCharacterControllerInterface.h" + +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// Targeting ../BulletDynamics/btKinematicCharacterController.java + + + +// #endif // BT_KINEMATIC_CHARACTER_CONTROLLER_H + + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index 0a32c4c1559..5f344259732 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -274,6 +274,9 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #include "btSoftBodyHelpers.h" // #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" // #include +// Targeting ../BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java + + // Targeting ../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java From 43ea07e265dd1d29a1ac2bffff39dc9dd94badf0 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Mar 2022 17:51:59 +0800 Subject: [PATCH 55/81] Complete mapping of BulletSoftBody library --- bullet/cppbuild.sh | 3 + .../bullet/presets/BulletSoftBody.java | 174 +++++++++++++----- .../bytedeco/bullet/presets/LinearMath.java | 1 + 3 files changed, 129 insertions(+), 49 deletions(-) diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh index 5f3396a4e37..e72099be73f 100755 --- a/bullet/cppbuild.sh +++ b/bullet/cppbuild.sh @@ -215,4 +215,7 @@ case $PLATFORM in ;; esac +sed -i "s/\(typedef.*btSolverCallback.*;\)/public: \1 private:/g" \ + ${INSTALL_PATH}/include/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h + cd ../../.. diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 9104f6e114a..58046f23f4f 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -40,19 +40,39 @@ @Platform( include = { "LinearMath/btAlignedObjectArray.h", + "BulletSoftBody/btSoftBody.h", + "BulletSoftBody/btCGProjection.h", + "BulletSoftBody/btConjugateGradient.h", + "BulletSoftBody/btConjugateResidual.h", + "BulletSoftBody/btDefaultSoftBodySolver.h", "BulletSoftBody/btDeformableBackwardEulerObjective.h", "BulletSoftBody/btDeformableBodySolver.h", + "BulletSoftBody/btDeformableContactConstraint.h", + "BulletSoftBody/btDeformableContactProjection.h", "BulletSoftBody/btDeformableLagrangianForce.h", + "BulletSoftBody/btDeformableCorotatedForce.h", + "BulletSoftBody/btDeformableGravityForce.h", + "BulletSoftBody/btDeformableLinearElasticityForce.h", + "BulletSoftBody/btDeformableMassSpringForce.h", + "BulletSoftBody/btDeformableMousePickingForce.h", "BulletSoftBody/btDeformableMultiBodyConstraintSolver.h", "BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h", - "BulletSoftBody/btSoftBody.h", + "BulletSoftBody/btDeformableNeoHookeanForce.h", + "BulletSoftBody/btKrylovSolver.h", + "BulletSoftBody/btPreconditioner.h", + "BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h", + "BulletSoftBody/btSoftBodyData.h", "BulletSoftBody/btSoftBodyHelpers.h", + "BulletSoftBody/btSoftBodyInternals.h", "BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h", - "BulletSoftBody/btSoftBodySolverVertexBuffer.h", "BulletSoftBody/btSoftBodySolvers.h", + "BulletSoftBody/btSoftBodySolverVertexBuffer.h", "BulletSoftBody/btSoftMultiBodyDynamicsWorld.h", + "BulletSoftBody/btSoftRigidCollisionAlgorithm.h", "BulletSoftBody/btSoftRigidDynamicsWorld.h", + "BulletSoftBody/btSoftSoftCollisionAlgorithm.h", "BulletSoftBody/btSparseSDF.h", + "BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.h", }, link = "BulletSoftBody@.3.20" ) @@ -67,15 +87,41 @@ public void map(InfoMap infoMap) { infoMap .put(new Info("btSoftBodyData").cppTypes().translate(false)) + .put(new Info( + "USE_MGS" + ).define(false)) + .put(new Info("btSoftBodySolver::SolverTypes").enumerate()) + .put(new Info("btVertexBufferDescriptor::BufferTypes").enumerate()) + + .put(new Info("btDeformableBackwardEulerObjective").immutable(true)) + .put(new Info("TVStack").pointerTypes("btVector3Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("LagrangeMultiplierArray")) + .put(new Info("btAlignedObjectArray >").pointerTypes("btDeformableFaceNodeContactConstraintArrayArray")) + .put(new Info("btAlignedObjectArray >").pointerTypes("btDeformableFaceRigidContactConstraintArrayArray")) + .put(new Info("btAlignedObjectArray >").pointerTypes("btDeformableNodeAnchorConstraintArrayArray")) + .put(new Info("btAlignedObjectArray >").pointerTypes("btDeformableNodeRigidContactConstraintArrayArray")) + .put(new Info("btAlignedObjectArray >").pointerTypes("btDeformableStaticConstraintArrayArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDeformableContactConstraintArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDeformableFaceNodeContactConstraintArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDeformableFaceRigidContactConstraintArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDeformableLagrangianForceArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDeformableNodeAnchorConstraintArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDeformableNodeRigidContactConstraintArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btDeformableStaticConstraintArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyAnchorArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyClusterArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyDeformableFaceNodeContactArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyDeformableFaceRigidContactArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyDeformableNodeRigidAnchorArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyDeformableNodeRigidContactArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyFaceArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyJointArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyLinkArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyMaterialArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyNodePointerArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyNodeArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyNoteArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyRContactArray")) @@ -83,8 +129,15 @@ public void map(InfoMap infoMap) { .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyRenderNodeArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodySContactArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyTetraArray")) + .put(new Info("btAlignedObjectArray").pointerTypes("btSoftBodyTetraSratchArray")) + .put(new Info("btAlignedObjectArray::Cell*>").pointerTypes("btSparseSdf3CellArray")) + .put(new Info("btDeformableBodySolver::TVStack").pointerTypes("btVector3Array")) .put(new Info("btSoftBody::Anchor").pointerTypes("btSoftBody.Anchor")) .put(new Info("btSoftBody::Cluster").pointerTypes("btSoftBody.Cluster")) + .put(new Info("btSoftBody::DeformableFaceNodeContact").pointerTypes("btSoftBody.DeformableFaceNodeContact")) + .put(new Info("btSoftBody::DeformableFaceRigidContact").pointerTypes("btSoftBody.DeformableFaceRigidContact")) + .put(new Info("btSoftBody::DeformableNodeRigidAnchor").pointerTypes("btSoftBody.DeformableNodeRigidAnchor")) + .put(new Info("btSoftBody::DeformableNodeRigidContact").pointerTypes("btSoftBody.DeformableNodeRigidContact")) .put(new Info("btSoftBody::Face").pointerTypes("btSoftBody.Face")) .put(new Info("btSoftBody::Joint").pointerTypes("btSoftBody.Joint")) .put(new Info("btSoftBody::Link").pointerTypes("btSoftBody.Link")) @@ -96,14 +149,78 @@ public void map(InfoMap infoMap) { .put(new Info("btSoftBody::RenderNode").pointerTypes("btSoftBody.RenderNode")) .put(new Info("btSoftBody::SContact").pointerTypes("btSoftBody.SContact")) .put(new Info("btSoftBody::Tetra").pointerTypes("btSoftBody.Tetra")) - .put(new Info("btSparseSdf<3>").pointerTypes("btSparseSdf_3")) + .put(new Info("btSoftBody::TetraScratch").pointerTypes("btSoftBody.TetraScratch")) + .put(new Info("btSparseSdf<3>").pointerTypes("btSparseSdf3")) + .put(new Info("btSparseSdf<3>::Cell").pointerTypes("btSparseSdf3.Cell")) + .put(new Info("btSparseSdf<3>::IntFrac").pointerTypes("btSparseSdf3.IntFrac")) .put(new Info( + "DeformableContactConstraint::m_contact", "SAFE_EPSILON", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", + "btAlignedObjectArray >::findBinarySearch", + "btAlignedObjectArray >::findLinearSearch", + "btAlignedObjectArray >::findLinearSearch2", + "btAlignedObjectArray >::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btAlignedObjectArray::findBinarySearch", "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", @@ -140,57 +257,16 @@ public void map(InfoMap infoMap) { "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", - "btCPUVertexBufferDescriptor::getBufferType", - "btDeformableBackwardEulerObjective::computeStep", - "btDeformableBackwardEulerObjective::getIndices", - "btDeformableBackwardEulerObjective::m_KKTPreconditioner", - "btDeformableBackwardEulerObjective::m_lf", - "btDeformableBackwardEulerObjective::m_massPreconditioner", - "btDeformableBackwardEulerObjective::m_nodes", - "btDeformableBackwardEulerObjective::m_preconditioner", - "btDeformableBackwardEulerObjective::m_projection", - "btDeformableBodySolver::computeDescentStep", - "btDeformableBodySolver::computeStep", - "btDeformableLagrangianForce::m_nodes", - "btDeformableLagrangianForce::setIndices", + "btAlignedObjectArray::findBinarySearch", + "btAlignedObjectArray::findLinearSearch", + "btAlignedObjectArray::findLinearSearch2", + "btAlignedObjectArray::remove", "btDeformableMultiBodyDynamicsWorld::rayTestSingle", - "btDeformableMultiBodyDynamicsWorld::setSolverCallback", - "btDeformableMultiBodyDynamicsWorld::solveMultiBodyConstraints", "btSoftBody::AJoint::Type", "btSoftBody::CJoint::Type", - "btSoftBody::Cluster::m_leaf", - "btSoftBody::Cluster::m_nodes", - "btSoftBody::Face::m_leaf", - "btSoftBody::Joint::eType", - "btSoftBody::Joint::eType::_", "btSoftBody::LJoint::Type", - "btSoftBody::Node::m_leaf", - "btSoftBody::RayFromToCaster", - "btSoftBody::Tetra::m_leaf", - "btSoftBody::ePSolver", - "btSoftBody::eVSolver", - "btSoftBody::fCollision", - "btSoftBody::fMaterial", - "btSoftBody::getSolver", "btSoftBody::m_collisionDisabledObjects", - "btSoftBody::m_deformableAnchors", - "btSoftBody::m_faceNodeContacts", - "btSoftBody::m_faceRigidContacts", - "btSoftBody::m_fdbvnt", - "btSoftBody::m_nodeRigidContacts", - "btSoftBody::m_renderNodesParents", - "btSoftBody::m_tetraScratches", - "btSoftBody::m_tetraScratchesTn", - "btSoftBody::solveClusters", - "btSoftBody::tPSolverArray", - "btSoftBody::tVSolverArray", - "btSoftBody::updateNode", - "btSoftBodyLinkData", - "btSoftBodyTriangleData", - "btSoftBodyVertexData", - "btSparseSdf<3>::Cell", - "btSparseSdf<3>::IntFrac", - "btSparseSdf<3>::cells" + "btSoftBody::m_renderNodesParents" ).skip()) ; } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index e58f75dbf22..288d3930f4e 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -127,6 +127,7 @@ public void map(InfoMap infoMap) { .put(new Info("btAlignedObjectArray").pointerTypes("btConvexHullComputerEdgeArray")) .put(new Info("btConvexHullComputer::Edge").pointerTypes("btConvexHullComputer.Edge")) .put(new Info("btHashMap").pointerTypes("btHashMap_btHashPtr_voidPointer")) + .put(new Info("btHashMap >").pointerTypes("btHashMap_btHashInt_btVector3Array")) .put(new Info("btAlignedObjectArray >").javaNames("btIntArrayArray")) .put(new Info("btAlignedObjectArray >").javaNames("btUnsignedIntArrayArray")) .put(new Info("btAlignedObjectArray >").javaNames("btDoubleArrayArray")) From a7482c838681d165606aaf3a780f58f9d8e32ea4 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Mar 2022 18:10:53 +0800 Subject: [PATCH 56/81] Update generate code of bullet preset See parent commit. --- bullet/cppbuild.sh | 2 +- .../BulletSoftBody/DefaultPreconditioner.java | 40 + ...rmableBodyInplaceSolverIslandCallback.java | 18 +- .../DeformableContactConstraint.java | 51 + .../BulletSoftBody/KKTPreconditioner.java | 39 + .../BulletSoftBody/LagrangeMultiplier.java | 46 + .../LagrangeMultiplierArray.java | 96 ++ .../BulletSoftBody/MassPreconditioner.java | 32 + .../bullet/BulletSoftBody/Preconditioner.java | 28 + .../BulletSoftBody/SoftBodyClusterData.java | 70 + .../BulletSoftBody/SoftBodyConfigData.java | 64 + .../BulletSoftBody/SoftBodyFaceData.java | 43 + .../BulletSoftBody/SoftBodyLinkData.java | 43 + .../BulletSoftBody/SoftBodyMaterialData.java | 42 + .../BulletSoftBody/SoftBodyNodeData.java | 48 + .../BulletSoftBody/SoftBodyPoseData.java | 52 + .../BulletSoftBody/SoftBodyTetraData.java | 47 + .../BulletSoftBody/SoftRigidAnchorData.java | 44 + .../bullet/BulletSoftBody/btCGProjection.java | 42 + .../btCPUVertexBufferDescriptor.java | 2 +- .../btDefaultSoftBodySolver.java | 59 + .../btDeformableBackwardEulerObjective.java | 22 +- .../btDeformableBodySolver.java | 5 +- .../btDeformableContactConstraint.java | 53 + .../btDeformableContactConstraintArray.java | 92 ++ .../btDeformableContactProjection.java | 78 + .../btDeformableCorotatedForce.java | 60 + ...btDeformableFaceNodeContactConstraint.java | 65 + ...ormableFaceNodeContactConstraintArray.java | 92 ++ ...leFaceNodeContactConstraintArrayArray.java | 92 ++ ...tDeformableFaceRigidContactConstraint.java | 61 + ...rmableFaceRigidContactConstraintArray.java | 92 ++ ...eFaceRigidContactConstraintArrayArray.java | 92 ++ .../btDeformableGravityForce.java | 49 + .../btDeformableLagrangianForce.java | 4 +- .../btDeformableLagrangianForceArray.java | 92 ++ .../btDeformableLinearElasticityForce.java | 96 ++ .../btDeformableMassSpringForce.java | 61 + .../btDeformableMousePickingForce.java | 52 + .../btDeformableMultiBodyDynamicsWorld.java | 13 +- .../btDeformableNeoHookeanForce.java | 102 ++ .../btDeformableNodeAnchorConstraint.java | 55 + ...btDeformableNodeAnchorConstraintArray.java | 92 ++ ...ormableNodeAnchorConstraintArrayArray.java | 92 ++ ...tDeformableNodeRigidContactConstraint.java | 62 + ...rmableNodeRigidContactConstraintArray.java | 92 ++ ...eNodeRigidContactConstraintArrayArray.java | 92 ++ .../btDeformableRigidContactConstraint.java | 51 + .../btDeformableStaticConstraint.java | 56 + .../btDeformableStaticConstraintArray.java | 92 ++ ...tDeformableStaticConstraintArrayArray.java | 92 ++ .../bullet/BulletSoftBody/btEigen.java | 45 + .../bullet/BulletSoftBody/btSoftBody.java | 200 ++- .../BulletSoftBody/btSoftBodyArray.java | 4 - .../btSoftBodyCollisionShape.java | 43 + .../btSoftBodyConcaveCollisionAlgorithm.java | 77 + ...oftBodyDeformableFaceNodeContactArray.java | 92 ++ ...ftBodyDeformableFaceRigidContactArray.java | 92 ++ ...oftBodyDeformableNodeRigidAnchorArray.java | 92 ++ ...ftBodyDeformableNodeRigidContactArray.java | 92 ++ .../BulletSoftBody/btSoftBodyFloatData.java | 61 + .../BulletSoftBody/btSoftBodyJointData.java | 52 + .../BulletSoftBody/btSoftBodyLinkData.java | 25 + .../btSoftBodyNodePointerArray.java | 92 ++ .../btSoftBodyTetraSratchArray.java | 92 ++ .../btSoftBodyTriangleCallback.java | 42 + .../btSoftBodyTriangleData.java | 26 + .../BulletSoftBody/btSoftBodyVertexData.java | 25 + .../BulletSoftBody/btSoftBodyWorldInfo.java | 2 +- .../btSoftClusterCollisionShape.java | 50 + .../BulletSoftBody/btSoftColliders.java | 319 +++++ .../btSoftRigidCollisionAlgorithm.java | 55 + .../btSoftSoftCollisionAlgorithm.java | 58 + .../bullet/BulletSoftBody/btSparseSdf3.java | 134 ++ .../BulletSoftBody/btSparseSdf3CellArray.java | 92 ++ .../bullet/BulletSoftBody/btSparseSdf_3.java | 85 -- .../bullet/BulletSoftBody/btTriIndex.java | 35 + .../btVertexBufferDescriptor.java | 18 +- .../btHashMap_btHashInt_btVector3Array.java | 48 + .../bullet/global/BulletSoftBody.java | 1264 +++++++++++++++-- .../bytedeco/bullet/global/LinearMath.java | 3 + 81 files changed, 5993 insertions(+), 279 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DefaultPreconditioner.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableContactConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/KKTPreconditioner.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/LagrangeMultiplier.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/LagrangeMultiplierArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MassPreconditioner.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/Preconditioner.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyClusterData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyConfigData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyFaceData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyLinkData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyMaterialData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyNodeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyPoseData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyTetraData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftRigidAnchorData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCGProjection.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDefaultSoftBodySolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactProjection.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableCorotatedForce.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraintArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraintArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableGravityForce.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForceArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLinearElasticityForce.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMassSpringForce.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMousePickingForce.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNeoHookeanForce.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraintArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraintArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableRigidContactConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraintArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btEigen.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyCollisionShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableFaceNodeContactArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableFaceRigidContactArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableNodeRigidAnchorArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableNodeRigidContactArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyJointData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNodePointerArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTetraSratchArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftClusterCollisionShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftColliders.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftSoftCollisionAlgorithm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf3CellArray.java delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btTriIndex.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashInt_btVector3Array.java diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh index e72099be73f..3b368f9ade4 100755 --- a/bullet/cppbuild.sh +++ b/bullet/cppbuild.sh @@ -14,7 +14,7 @@ mkdir -p $PLATFORM cd $PLATFORM INSTALL_PATH=`pwd` echo "Decompressing archives..." -unzip -qo ../bullet-$BULLET_VERSION.zip +# unzip -qo ../bullet-$BULLET_VERSION.zip cd bullet3-$BULLET_VERSION mkdir -p build cd build diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DefaultPreconditioner.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DefaultPreconditioner.java new file mode 100644 index 00000000000..46a938731df --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DefaultPreconditioner.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class DefaultPreconditioner extends Preconditioner { + static { Loader.load(); } + /** Default native constructor. */ + public DefaultPreconditioner() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DefaultPreconditioner(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DefaultPreconditioner(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public DefaultPreconditioner position(long position) { + return (DefaultPreconditioner)super.position(position); + } + @Override public DefaultPreconditioner getPointer(long i) { + return new DefaultPreconditioner((Pointer)this).offsetAddress(i); + } + + public native @Name("operator ()") void apply(@Const @ByRef btVector3Array x, @ByRef btVector3Array b); + public native void reinitialize(@Cast("bool") boolean nodeUpdated); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java index 10804c8f9eb..81880f23fa6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java @@ -16,10 +16,20 @@ import static org.bytedeco.bullet.global.BulletSoftBody.*; -@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class DeformableBodyInplaceSolverIslandCallback extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public DeformableBodyInplaceSolverIslandCallback() { super((Pointer)null); } + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class DeformableBodyInplaceSolverIslandCallback extends MultiBodyInplaceSolverIslandCallback { + static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public DeformableBodyInplaceSolverIslandCallback(Pointer p) { super(p); } + + public native btDeformableMultiBodyConstraintSolver m_deformableSolver(); public native DeformableBodyInplaceSolverIslandCallback m_deformableSolver(btDeformableMultiBodyConstraintSolver setter); + + public DeformableBodyInplaceSolverIslandCallback(btDeformableMultiBodyConstraintSolver solver, + btDispatcher dispatcher) { super((Pointer)null); allocate(solver, dispatcher); } + private native void allocate(btDeformableMultiBodyConstraintSolver solver, + btDispatcher dispatcher); + + public native void processConstraints(int islandId/*=-1*/); + public native void processConstraints(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableContactConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableContactConstraint.java new file mode 100644 index 00000000000..95ea9e4231a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/DeformableContactConstraint.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class DeformableContactConstraint extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public DeformableContactConstraint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public DeformableContactConstraint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public DeformableContactConstraint position(long position) { + return (DeformableContactConstraint)super.position(position); + } + @Override public DeformableContactConstraint getPointer(long i) { + return new DeformableContactConstraint((Pointer)this).offsetAddress(i); + } + + public native @Const btSoftBody.Node m_node(); public native DeformableContactConstraint m_node(btSoftBody.Node setter); + + public native @ByRef btVector3Array m_total_normal_dv(); public native DeformableContactConstraint m_total_normal_dv(btVector3Array setter); + public native @ByRef btVector3Array m_total_tangent_dv(); public native DeformableContactConstraint m_total_tangent_dv(btVector3Array setter); + public native @ByRef btBoolArray m_static(); public native DeformableContactConstraint m_static(btBoolArray setter); + public native @ByRef btBoolArray m_can_be_dynamic(); public native DeformableContactConstraint m_can_be_dynamic(btBoolArray setter); + + public DeformableContactConstraint(@Const @ByRef btSoftBody.RContact rcontact) { super((Pointer)null); allocate(rcontact); } + private native void allocate(@Const @ByRef btSoftBody.RContact rcontact); + + public DeformableContactConstraint() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void append(@Const @ByRef btSoftBody.RContact rcontact); + + public native void replace(@Const @ByRef btSoftBody.RContact rcontact); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/KKTPreconditioner.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/KKTPreconditioner.java new file mode 100644 index 00000000000..f72db3e7ad3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/KKTPreconditioner.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class KKTPreconditioner extends Preconditioner { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public KKTPreconditioner(Pointer p) { super(p); } + + public KKTPreconditioner(@Const @ByRef btSoftBodyArray softBodies, @Const @ByRef btDeformableContactProjection projections, @Const @ByRef btDeformableLagrangianForceArray lf, @Cast("const btScalar") float dt, @Cast("const bool") boolean implicit) { super((Pointer)null); allocate(softBodies, projections, lf, dt, implicit); } + private native void allocate(@Const @ByRef btSoftBodyArray softBodies, @Const @ByRef btDeformableContactProjection projections, @Const @ByRef btDeformableLagrangianForceArray lf, @Cast("const btScalar") float dt, @Cast("const bool") boolean implicit); + + public native void reinitialize(@Cast("bool") boolean nodeUpdated); + + public native void buildDiagonalA(@ByRef btVector3Array diagA); + + public native void buildDiagonalS(@Const @ByRef btVector3Array inv_A, @ByRef btVector3Array diagS); +//#define USE_FULL_PRECONDITIONER +// #ifndef USE_FULL_PRECONDITIONER + public native @Name("operator ()") void apply(@Const @ByRef btVector3Array x, @ByRef btVector3Array b); +// #else +// #endif +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/LagrangeMultiplier.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/LagrangeMultiplier.java new file mode 100644 index 00000000000..972d9b0d70c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/LagrangeMultiplier.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class LagrangeMultiplier extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public LagrangeMultiplier() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public LagrangeMultiplier(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LagrangeMultiplier(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public LagrangeMultiplier position(long position) { + return (LagrangeMultiplier)super.position(position); + } + @Override public LagrangeMultiplier getPointer(long i) { + return new LagrangeMultiplier((Pointer)this).offsetAddress(i); + } + + public native int m_num_constraints(); public native LagrangeMultiplier m_num_constraints(int setter); // Number of constraints + public native int m_num_nodes(); public native LagrangeMultiplier m_num_nodes(int setter); // Number of nodes in these constraints + public native @Cast("btScalar") float m_weights(int i); public native LagrangeMultiplier m_weights(int i, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer m_weights(); // weights of the nodes involved, same size as m_num_nodes + public native @ByRef btVector3 m_dirs(int i); public native LagrangeMultiplier m_dirs(int i, btVector3 setter); + @MemberGetter public native btVector3 m_dirs(); // Constraint directions, same size of m_num_constraints; + public native int m_indices(int i); public native LagrangeMultiplier m_indices(int i, int setter); + @MemberGetter public native IntPointer m_indices(); // indices of the nodes involved, same size as m_num_nodes; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/LagrangeMultiplierArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/LagrangeMultiplierArray.java new file mode 100644 index 00000000000..3f1442468ad --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/LagrangeMultiplierArray.java @@ -0,0 +1,96 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + //for placement new +// #endif //BT_USE_PLACEMENT_NEW + +/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class LagrangeMultiplierArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public LagrangeMultiplierArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public LagrangeMultiplierArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public LagrangeMultiplierArray position(long position) { + return (LagrangeMultiplierArray)super.position(position); + } + @Override public LagrangeMultiplierArray getPointer(long i) { + return new LagrangeMultiplierArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") LagrangeMultiplierArray put(@Const @ByRef LagrangeMultiplierArray other); + public LagrangeMultiplierArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public LagrangeMultiplierArray(@Const @ByRef LagrangeMultiplierArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef LagrangeMultiplierArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef LagrangeMultiplier at(int n); + + public native @ByRef @Name("operator []") LagrangeMultiplier get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "LagrangeMultiplier()") LagrangeMultiplier fillData); + public native void resize(int newsize); + public native @ByRef LagrangeMultiplier expandNonInitializing(); + + public native @ByRef LagrangeMultiplier expand(@Const @ByRef(nullValue = "LagrangeMultiplier()") LagrangeMultiplier fillValue); + public native @ByRef LagrangeMultiplier expand(); + + public native void push_back(@Const @ByRef LagrangeMultiplier _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef LagrangeMultiplierArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MassPreconditioner.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MassPreconditioner.java new file mode 100644 index 00000000000..e898edb58d7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/MassPreconditioner.java @@ -0,0 +1,32 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class MassPreconditioner extends Preconditioner { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public MassPreconditioner(Pointer p) { super(p); } + + public MassPreconditioner(@Const @ByRef btSoftBodyArray softBodies) { super((Pointer)null); allocate(softBodies); } + private native void allocate(@Const @ByRef btSoftBodyArray softBodies); + + public native void reinitialize(@Cast("bool") boolean nodeUpdated); + + public native @Name("operator ()") void apply(@Const @ByRef btVector3Array x, @ByRef btVector3Array b); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/Preconditioner.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/Preconditioner.java new file mode 100644 index 00000000000..3a2e797e5c5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/Preconditioner.java @@ -0,0 +1,28 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class Preconditioner extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Preconditioner(Pointer p) { super(p); } + + public native @Name("operator ()") void apply(@Cast("const Preconditioner::TVStack*") @ByRef btVector3Array x, @Cast("Preconditioner::TVStack*") @ByRef btVector3Array b); + public native void reinitialize(@Cast("bool") boolean nodeUpdated); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyClusterData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyClusterData.java new file mode 100644 index 00000000000..15f36276fe0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyClusterData.java @@ -0,0 +1,70 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftBodyClusterData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftBodyClusterData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftBodyClusterData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftBodyClusterData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftBodyClusterData position(long position) { + return (SoftBodyClusterData)super.position(position); + } + @Override public SoftBodyClusterData getPointer(long i) { + return new SoftBodyClusterData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btTransformFloatData m_framexform(); public native SoftBodyClusterData m_framexform(btTransformFloatData setter); + public native @ByRef btMatrix3x3FloatData m_locii(); public native SoftBodyClusterData m_locii(btMatrix3x3FloatData setter); + public native @ByRef btMatrix3x3FloatData m_invwi(); public native SoftBodyClusterData m_invwi(btMatrix3x3FloatData setter); + public native @ByRef btVector3FloatData m_com(); public native SoftBodyClusterData m_com(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_vimpulses(int i); public native SoftBodyClusterData m_vimpulses(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_vimpulses(); + public native @ByRef btVector3FloatData m_dimpulses(int i); public native SoftBodyClusterData m_dimpulses(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_dimpulses(); + public native @ByRef btVector3FloatData m_lv(); public native SoftBodyClusterData m_lv(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_av(); public native SoftBodyClusterData m_av(btVector3FloatData setter); + + public native btVector3FloatData m_framerefs(); public native SoftBodyClusterData m_framerefs(btVector3FloatData setter); + public native IntPointer m_nodeIndices(); public native SoftBodyClusterData m_nodeIndices(IntPointer setter); + public native FloatPointer m_masses(); public native SoftBodyClusterData m_masses(FloatPointer setter); + + public native int m_numFrameRefs(); public native SoftBodyClusterData m_numFrameRefs(int setter); + public native int m_numNodes(); public native SoftBodyClusterData m_numNodes(int setter); + public native int m_numMasses(); public native SoftBodyClusterData m_numMasses(int setter); + + public native float m_idmass(); public native SoftBodyClusterData m_idmass(float setter); + public native float m_imass(); public native SoftBodyClusterData m_imass(float setter); + public native int m_nvimpulses(); public native SoftBodyClusterData m_nvimpulses(int setter); + public native int m_ndimpulses(); public native SoftBodyClusterData m_ndimpulses(int setter); + public native float m_ndamping(); public native SoftBodyClusterData m_ndamping(float setter); + public native float m_ldamping(); public native SoftBodyClusterData m_ldamping(float setter); + public native float m_adamping(); public native SoftBodyClusterData m_adamping(float setter); + public native float m_matching(); public native SoftBodyClusterData m_matching(float setter); + public native float m_maxSelfCollisionImpulse(); public native SoftBodyClusterData m_maxSelfCollisionImpulse(float setter); + public native float m_selfCollisionImpulseFactor(); public native SoftBodyClusterData m_selfCollisionImpulseFactor(float setter); + public native int m_containsAnchor(); public native SoftBodyClusterData m_containsAnchor(int setter); + public native int m_collide(); public native SoftBodyClusterData m_collide(int setter); + public native int m_clusterIndex(); public native SoftBodyClusterData m_clusterIndex(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyConfigData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyConfigData.java new file mode 100644 index 00000000000..2531a5237b3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyConfigData.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftBodyConfigData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftBodyConfigData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftBodyConfigData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftBodyConfigData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftBodyConfigData position(long position) { + return (SoftBodyConfigData)super.position(position); + } + @Override public SoftBodyConfigData getPointer(long i) { + return new SoftBodyConfigData((Pointer)this).offsetAddress(i); + } + + public native int m_aeroModel(); public native SoftBodyConfigData m_aeroModel(int setter); // Aerodynamic model (default: V_Point) + public native float m_baumgarte(); public native SoftBodyConfigData m_baumgarte(float setter); // Velocities correction factor (Baumgarte) + public native float m_damping(); public native SoftBodyConfigData m_damping(float setter); // Damping coefficient [0,1] + public native float m_drag(); public native SoftBodyConfigData m_drag(float setter); // Drag coefficient [0,+inf] + public native float m_lift(); public native SoftBodyConfigData m_lift(float setter); // Lift coefficient [0,+inf] + public native float m_pressure(); public native SoftBodyConfigData m_pressure(float setter); // Pressure coefficient [-inf,+inf] + public native float m_volume(); public native SoftBodyConfigData m_volume(float setter); // Volume conversation coefficient [0,+inf] + public native float m_dynamicFriction(); public native SoftBodyConfigData m_dynamicFriction(float setter); // Dynamic friction coefficient [0,1] + public native float m_poseMatch(); public native SoftBodyConfigData m_poseMatch(float setter); // Pose matching coefficient [0,1] + public native float m_rigidContactHardness(); public native SoftBodyConfigData m_rigidContactHardness(float setter); // Rigid contacts hardness [0,1] + public native float m_kineticContactHardness(); public native SoftBodyConfigData m_kineticContactHardness(float setter); // Kinetic contacts hardness [0,1] + public native float m_softContactHardness(); public native SoftBodyConfigData m_softContactHardness(float setter); // Soft contacts hardness [0,1] + public native float m_anchorHardness(); public native SoftBodyConfigData m_anchorHardness(float setter); // Anchors hardness [0,1] + public native float m_softRigidClusterHardness(); public native SoftBodyConfigData m_softRigidClusterHardness(float setter); // Soft vs rigid hardness [0,1] (cluster only) + public native float m_softKineticClusterHardness(); public native SoftBodyConfigData m_softKineticClusterHardness(float setter); // Soft vs kinetic hardness [0,1] (cluster only) + public native float m_softSoftClusterHardness(); public native SoftBodyConfigData m_softSoftClusterHardness(float setter); // Soft vs soft hardness [0,1] (cluster only) + public native float m_softRigidClusterImpulseSplit(); public native SoftBodyConfigData m_softRigidClusterImpulseSplit(float setter); // Soft vs rigid impulse split [0,1] (cluster only) + public native float m_softKineticClusterImpulseSplit(); public native SoftBodyConfigData m_softKineticClusterImpulseSplit(float setter); // Soft vs rigid impulse split [0,1] (cluster only) + public native float m_softSoftClusterImpulseSplit(); public native SoftBodyConfigData m_softSoftClusterImpulseSplit(float setter); // Soft vs rigid impulse split [0,1] (cluster only) + public native float m_maxVolume(); public native SoftBodyConfigData m_maxVolume(float setter); // Maximum volume ratio for pose + public native float m_timeScale(); public native SoftBodyConfigData m_timeScale(float setter); // Time scale + public native int m_velocityIterations(); public native SoftBodyConfigData m_velocityIterations(int setter); // Velocities solver iterations + public native int m_positionIterations(); public native SoftBodyConfigData m_positionIterations(int setter); // Positions solver iterations + public native int m_driftIterations(); public native SoftBodyConfigData m_driftIterations(int setter); // Drift solver iterations + public native int m_clusterIterations(); public native SoftBodyConfigData m_clusterIterations(int setter); // Cluster solver iterations + public native int m_collisionFlags(); public native SoftBodyConfigData m_collisionFlags(int setter); // Collisions flags +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyFaceData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyFaceData.java new file mode 100644 index 00000000000..1f8841d5414 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyFaceData.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftBodyFaceData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftBodyFaceData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftBodyFaceData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftBodyFaceData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftBodyFaceData position(long position) { + return (SoftBodyFaceData)super.position(position); + } + @Override public SoftBodyFaceData getPointer(long i) { + return new SoftBodyFaceData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_normal(); public native SoftBodyFaceData m_normal(btVector3FloatData setter); // Normal + public native SoftBodyMaterialData m_material(); public native SoftBodyFaceData m_material(SoftBodyMaterialData setter); + public native int m_nodeIndices(int i); public native SoftBodyFaceData m_nodeIndices(int i, int setter); + @MemberGetter public native IntPointer m_nodeIndices(); // Node pointers + public native float m_restArea(); public native SoftBodyFaceData m_restArea(float setter); // Rest area +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyLinkData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyLinkData.java new file mode 100644 index 00000000000..ebe5599b1d3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyLinkData.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftBodyLinkData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftBodyLinkData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftBodyLinkData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftBodyLinkData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftBodyLinkData position(long position) { + return (SoftBodyLinkData)super.position(position); + } + @Override public SoftBodyLinkData getPointer(long i) { + return new SoftBodyLinkData((Pointer)this).offsetAddress(i); + } + + public native SoftBodyMaterialData m_material(); public native SoftBodyLinkData m_material(SoftBodyMaterialData setter); + public native int m_nodeIndices(int i); public native SoftBodyLinkData m_nodeIndices(int i, int setter); + @MemberGetter public native IntPointer m_nodeIndices(); // Node pointers + public native float m_restLength(); public native SoftBodyLinkData m_restLength(float setter); // Rest length + public native int m_bbending(); public native SoftBodyLinkData m_bbending(int setter); // Bending link +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyMaterialData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyMaterialData.java new file mode 100644 index 00000000000..0298fe90b66 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyMaterialData.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftBodyMaterialData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftBodyMaterialData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftBodyMaterialData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftBodyMaterialData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftBodyMaterialData position(long position) { + return (SoftBodyMaterialData)super.position(position); + } + @Override public SoftBodyMaterialData getPointer(long i) { + return new SoftBodyMaterialData((Pointer)this).offsetAddress(i); + } + + public native float m_linearStiffness(); public native SoftBodyMaterialData m_linearStiffness(float setter); + public native float m_angularStiffness(); public native SoftBodyMaterialData m_angularStiffness(float setter); + public native float m_volumeStiffness(); public native SoftBodyMaterialData m_volumeStiffness(float setter); + public native int m_flags(); public native SoftBodyMaterialData m_flags(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyNodeData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyNodeData.java new file mode 100644 index 00000000000..eb6aa90b067 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyNodeData.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftBodyNodeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftBodyNodeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftBodyNodeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftBodyNodeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftBodyNodeData position(long position) { + return (SoftBodyNodeData)super.position(position); + } + @Override public SoftBodyNodeData getPointer(long i) { + return new SoftBodyNodeData((Pointer)this).offsetAddress(i); + } + + public native SoftBodyMaterialData m_material(); public native SoftBodyNodeData m_material(SoftBodyMaterialData setter); + public native @ByRef btVector3FloatData m_position(); public native SoftBodyNodeData m_position(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_previousPosition(); public native SoftBodyNodeData m_previousPosition(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_velocity(); public native SoftBodyNodeData m_velocity(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_accumulatedForce(); public native SoftBodyNodeData m_accumulatedForce(btVector3FloatData setter); + public native @ByRef btVector3FloatData m_normal(); public native SoftBodyNodeData m_normal(btVector3FloatData setter); + public native float m_inverseMass(); public native SoftBodyNodeData m_inverseMass(float setter); + public native float m_area(); public native SoftBodyNodeData m_area(float setter); + public native int m_attach(); public native SoftBodyNodeData m_attach(int setter); + public native int m_pad(); public native SoftBodyNodeData m_pad(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyPoseData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyPoseData.java new file mode 100644 index 00000000000..414f0d02859 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyPoseData.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftBodyPoseData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftBodyPoseData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftBodyPoseData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftBodyPoseData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftBodyPoseData position(long position) { + return (SoftBodyPoseData)super.position(position); + } + @Override public SoftBodyPoseData getPointer(long i) { + return new SoftBodyPoseData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3FloatData m_rot(); public native SoftBodyPoseData m_rot(btMatrix3x3FloatData setter); // Rotation + public native @ByRef btMatrix3x3FloatData m_scale(); public native SoftBodyPoseData m_scale(btMatrix3x3FloatData setter); // Scale + public native @ByRef btMatrix3x3FloatData m_aqq(); public native SoftBodyPoseData m_aqq(btMatrix3x3FloatData setter); // Base scaling + public native @ByRef btVector3FloatData m_com(); public native SoftBodyPoseData m_com(btVector3FloatData setter); // COM + + public native btVector3FloatData m_positions(); public native SoftBodyPoseData m_positions(btVector3FloatData setter); // Reference positions + public native FloatPointer m_weights(); public native SoftBodyPoseData m_weights(FloatPointer setter); // Weights + public native int m_numPositions(); public native SoftBodyPoseData m_numPositions(int setter); + public native int m_numWeigts(); public native SoftBodyPoseData m_numWeigts(int setter); + + public native int m_bvolume(); public native SoftBodyPoseData m_bvolume(int setter); // Is valid + public native int m_bframe(); public native SoftBodyPoseData m_bframe(int setter); // Is frame + public native float m_restVolume(); public native SoftBodyPoseData m_restVolume(float setter); // Rest volume + public native int m_pad(); public native SoftBodyPoseData m_pad(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyTetraData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyTetraData.java new file mode 100644 index 00000000000..7133641af5d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftBodyTetraData.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftBodyTetraData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftBodyTetraData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftBodyTetraData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftBodyTetraData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftBodyTetraData position(long position) { + return (SoftBodyTetraData)super.position(position); + } + @Override public SoftBodyTetraData getPointer(long i) { + return new SoftBodyTetraData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btVector3FloatData m_c0(int i); public native SoftBodyTetraData m_c0(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_c0(); // gradients + public native SoftBodyMaterialData m_material(); public native SoftBodyTetraData m_material(SoftBodyMaterialData setter); + public native int m_nodeIndices(int i); public native SoftBodyTetraData m_nodeIndices(int i, int setter); + @MemberGetter public native IntPointer m_nodeIndices(); // Node pointers + public native float m_restVolume(); public native SoftBodyTetraData m_restVolume(float setter); // Rest volume + public native float m_c1(); public native SoftBodyTetraData m_c1(float setter); // (4*kVST)/(im0+im1+im2+im3) + public native float m_c2(); public native SoftBodyTetraData m_c2(float setter); // m_c1/sum(|g0..3|^2) + public native int m_pad(); public native SoftBodyTetraData m_pad(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftRigidAnchorData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftRigidAnchorData.java new file mode 100644 index 00000000000..9ae3808c6fb --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/SoftRigidAnchorData.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class SoftRigidAnchorData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public SoftRigidAnchorData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SoftRigidAnchorData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SoftRigidAnchorData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SoftRigidAnchorData position(long position) { + return (SoftRigidAnchorData)super.position(position); + } + @Override public SoftRigidAnchorData getPointer(long i) { + return new SoftRigidAnchorData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btMatrix3x3FloatData m_c0(); public native SoftRigidAnchorData m_c0(btMatrix3x3FloatData setter); // Impulse matrix + public native @ByRef btVector3FloatData m_c1(); public native SoftRigidAnchorData m_c1(btVector3FloatData setter); // Relative anchor + public native @ByRef btVector3FloatData m_localFrame(); public native SoftRigidAnchorData m_localFrame(btVector3FloatData setter); // Anchor position in body space + public native btRigidBodyFloatData m_rigidBody(); public native SoftRigidAnchorData m_rigidBody(btRigidBodyFloatData setter); + public native int m_nodeIndex(); public native SoftRigidAnchorData m_nodeIndex(int setter); // Node pointer + public native float m_c2(); public native SoftRigidAnchorData m_c2(float setter); // ima*dt +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCGProjection.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCGProjection.java new file mode 100644 index 00000000000..29be35da35e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCGProjection.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btCGProjection extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btCGProjection(Pointer p) { super(p); } + + public native @ByRef btSoftBodyArray m_softBodies(); public native btCGProjection m_softBodies(btSoftBodyArray setter); + @MemberGetter public native @Cast("const btScalar") float m_dt(); + // map from node indices to node pointers + public native @Const btSoftBodyNodePointerArray m_nodes(); public native btCGProjection m_nodes(btSoftBodyNodePointerArray setter); + + // apply the constraints + public native void project(@Cast("btCGProjection::TVStack*") @ByRef btVector3Array x); + + public native void setConstraints(); + + // update the constraints + public native @Cast("btScalar") float update(); + + public native void reinitialize(@Cast("bool") boolean nodeUpdated); + + public native void setIndices(@Const btSoftBodyNodePointerArray nodes); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java index 4d96ff16c51..cb54518314f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btCPUVertexBufferDescriptor.java @@ -50,7 +50,7 @@ public class btCPUVertexBufferDescriptor extends btVertexBufferDescriptor { /** * Return the type of the vertex buffer descriptor. */ - + public native @ByVal BufferTypes getBufferType(); /** * Return the base pointer in memory to the first vertex. diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDefaultSoftBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDefaultSoftBodySolver.java new file mode 100644 index 00000000000..9527a8774ab --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDefaultSoftBodySolver.java @@ -0,0 +1,59 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDefaultSoftBodySolver extends btSoftBodySolver { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDefaultSoftBodySolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDefaultSoftBodySolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDefaultSoftBodySolver position(long position) { + return (btDefaultSoftBodySolver)super.position(position); + } + @Override public btDefaultSoftBodySolver getPointer(long i) { + return new btDefaultSoftBodySolver((Pointer)this).offsetAddress(i); + } + + public btDefaultSoftBodySolver() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @ByVal SolverTypes getSolverType(); + + public native @Cast("bool") boolean checkInitialized(); + + public native void updateSoftBodies(); + + public native void optimize(@ByRef btSoftBodyArray softBodies, @Cast("bool") boolean forceUpdate/*=false*/); + public native void optimize(@ByRef btSoftBodyArray softBodies); + + public native void copyBackToSoftBodies(@Cast("bool") boolean bMove/*=true*/); + public native void copyBackToSoftBodies(); + + public native void solveConstraints(@Cast("btScalar") float solverdt); + + public native void predictMotion(@Cast("btScalar") float solverdt); + + public native void copySoftBodyToVertexBuffer(@Const btSoftBody softBody, btVertexBufferDescriptor vertexBuffer); + + public native void processCollision(btSoftBody arg0, @Const btCollisionObjectWrapper arg1); + + public native void processCollision(btSoftBody arg0, btSoftBody arg1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java index 65730a25d69..287200e3235 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java @@ -23,16 +23,16 @@ public class btDeformableBackwardEulerObjective extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btDeformableBackwardEulerObjective(Pointer p) { super(p); } - public native @Cast("btScalar") float m_dt(); public native btDeformableBackwardEulerObjective m_dt(float setter); - - public native @ByRef btSoftBodyArray m_softBodies(); public native btDeformableBackwardEulerObjective m_softBodies(btSoftBodyArray setter); - - + @MemberGetter public native @Cast("btScalar") float m_dt(); + @MemberGetter public native @ByRef btDeformableLagrangianForceArray m_lf(); + @MemberGetter public native @ByRef btSoftBodyArray m_softBodies(); + @MemberGetter public native Preconditioner m_preconditioner(); + @MemberGetter public native @ByRef btDeformableContactProjection m_projection(); @MemberGetter public native @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array m_backupVelocity(); - - public native @Cast("bool") boolean m_implicit(); public native btDeformableBackwardEulerObjective m_implicit(boolean setter); - - + @MemberGetter public native @ByRef btSoftBodyNodePointerArray m_nodes(); + @MemberGetter public native @Cast("bool") boolean m_implicit(); + @MemberGetter public native MassPreconditioner m_massPreconditioner(); + @MemberGetter public native KKTPreconditioner m_KKTPreconditioner(); public btDeformableBackwardEulerObjective(@ByRef btSoftBodyArray softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array backup_v) { super((Pointer)null); allocate(softBodies, backup_v); } private native void allocate(@ByRef btSoftBodyArray softBodies, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array backup_v); @@ -52,7 +52,7 @@ public class btDeformableBackwardEulerObjective extends Pointer { public native @Cast("btScalar") float computeNorm(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array residual); // compute one step of the solve (there is only one solve if the system is linear) - + public native void computeStep(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array residual, @Cast("const btScalar") float dt); // perform A*x = b public native void multiply(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array b); @@ -83,7 +83,7 @@ public class btDeformableBackwardEulerObjective extends Pointer { // reindex all the vertices public native void updateId(); - + public native @Const btSoftBodyNodePointerArray getIndices(); public native void setImplicit(@Cast("bool") boolean implicit); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java index 439daccf871..6e254562b4d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBodySolver.java @@ -79,10 +79,11 @@ public class btDeformableBodySolver extends btSoftBodySolver { public native @Cast("bool") boolean updateNodes(); // calculate the change in dv resulting from the momentum solve - + public native void computeStep(@ByRef btVector3Array ddv, @Const @ByRef btVector3Array residual); // calculate the change in dv resulting from the momentum solve when line search is turned on - + public native @Cast("btScalar") float computeDescentStep(@ByRef btVector3Array ddv, @Const @ByRef btVector3Array residual, @Cast("bool") boolean verbose/*=false*/); + public native @Cast("btScalar") float computeDescentStep(@ByRef btVector3Array ddv, @Const @ByRef btVector3Array residual); public native void copySoftBodyToVertexBuffer(@Const btSoftBody softBody, btVertexBufferDescriptor vertexBuffer); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactConstraint.java new file mode 100644 index 00000000000..0b8b05abdb5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactConstraint.java @@ -0,0 +1,53 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// btDeformableContactConstraint is an abstract class specifying the method that each type of contact constraint needs to implement +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableContactConstraint extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableContactConstraint(Pointer p) { super(p); } + + // True if the friction is static + // False if the friction is dynamic + public native @Cast("bool") boolean m_static(); public native btDeformableContactConstraint m_static(boolean setter); + public native @Const btContactSolverInfo m_infoGlobal(); public native btDeformableContactConstraint m_infoGlobal(btContactSolverInfo setter); + + // normal of the contact + public native @ByRef btVector3 m_normal(); public native btDeformableContactConstraint m_normal(btVector3 setter); + + // solve the constraint with inelastic impulse and return the error, which is the square of normal component of velocity diffrerence + // the constraint is solved by calculating the impulse between object A and B in the contact and apply the impulse to both objects involved in the contact + public native @Cast("btScalar") float solveConstraint(@Const @ByRef btContactSolverInfo infoGlobal); + + // get the velocity of the object A in the contact + public native @ByVal btVector3 getVa(); + + // get the velocity of the object B in the contact + public native @ByVal btVector3 getVb(); + + // get the velocity change of the soft body node in the constraint + public native @ByVal btVector3 getDv(@Const btSoftBody.Node arg0); + + // apply impulse to the soft body node and/or face involved + public native void applyImpulse(@Const @ByRef btVector3 impulse); + + // scale the penetration depth by erp + public native void setPenetrationScale(@Cast("btScalar") float scale); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactConstraintArray.java new file mode 100644 index 00000000000..7b05a29c204 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactConstraintArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableContactConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableContactConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableContactConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableContactConstraintArray position(long position) { + return (btDeformableContactConstraintArray)super.position(position); + } + @Override public btDeformableContactConstraintArray getPointer(long i) { + return new btDeformableContactConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableContactConstraintArray put(@Const @ByRef btDeformableContactConstraintArray other); + public btDeformableContactConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableContactConstraintArray(@Const @ByRef btDeformableContactConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableContactConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btDeformableContactConstraint at(int n); + + public native @ByPtrRef @Name("operator []") btDeformableContactConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btDeformableContactConstraint fillData/*=btDeformableContactConstraint*()*/); + public native void resize(int newsize); + public native @ByPtrRef btDeformableContactConstraint expandNonInitializing(); + + public native @ByPtrRef btDeformableContactConstraint expand(@ByPtrRef btDeformableContactConstraint fillValue/*=btDeformableContactConstraint*()*/); + public native @ByPtrRef btDeformableContactConstraint expand(); + + public native void push_back(@ByPtrRef btDeformableContactConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btDeformableContactConstraint key); + + public native int findLinearSearch(@ByPtrRef btDeformableContactConstraint key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btDeformableContactConstraint key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btDeformableContactConstraint key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableContactConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactProjection.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactProjection.java new file mode 100644 index 00000000000..1909220c61d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableContactProjection.java @@ -0,0 +1,78 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableContactProjection extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableContactProjection(Pointer p) { super(p); } + + public native @ByRef btSoftBodyArray m_softBodies(); public native btDeformableContactProjection m_softBodies(btSoftBodyArray setter); + + // all constraints involving face + public native @ByRef btDeformableContactConstraintArray m_allFaceConstraints(); public native btDeformableContactProjection m_allFaceConstraints(btDeformableContactConstraintArray setter); +// #ifndef USE_MGS + // map from node index to projection directions + public native @ByRef btHashMap_btHashInt_btVector3Array m_projectionsDict(); public native btDeformableContactProjection m_projectionsDict(btHashMap_btHashInt_btVector3Array setter); +// #else +// #endif + + public native @ByRef LagrangeMultiplierArray m_lagrangeMultipliers(); public native btDeformableContactProjection m_lagrangeMultipliers(LagrangeMultiplierArray setter); + + // map from node index to static constraint + public native @ByRef btDeformableStaticConstraintArrayArray m_staticConstraints(); public native btDeformableContactProjection m_staticConstraints(btDeformableStaticConstraintArrayArray setter); + // map from node index to node rigid constraint + public native @ByRef btDeformableNodeRigidContactConstraintArrayArray m_nodeRigidConstraints(); public native btDeformableContactProjection m_nodeRigidConstraints(btDeformableNodeRigidContactConstraintArrayArray setter); + // map from node index to face rigid constraint + public native @ByRef btDeformableFaceRigidContactConstraintArrayArray m_faceRigidConstraints(); public native btDeformableContactProjection m_faceRigidConstraints(btDeformableFaceRigidContactConstraintArrayArray setter); + // map from node index to deformable constraint + public native @ByRef btDeformableFaceNodeContactConstraintArrayArray m_deformableConstraints(); public native btDeformableContactProjection m_deformableConstraints(btDeformableFaceNodeContactConstraintArrayArray setter); + // map from node index to node anchor constraint + public native @ByRef btDeformableNodeAnchorConstraintArrayArray m_nodeAnchorConstraints(); public native btDeformableContactProjection m_nodeAnchorConstraints(btDeformableNodeAnchorConstraintArrayArray setter); + + public native @Cast("bool") boolean m_useStrainLimiting(); public native btDeformableContactProjection m_useStrainLimiting(boolean setter); + + public btDeformableContactProjection(@ByRef btSoftBodyArray softBodies) { super((Pointer)null); allocate(softBodies); } + private native void allocate(@ByRef btSoftBodyArray softBodies); + + // apply the constraints to the rhs of the linear solve + public native void project(@Cast("btDeformableContactProjection::TVStack*") @ByRef btVector3Array x); + + // add friction force to the rhs of the linear solve + public native void applyDynamicFriction(@Cast("btDeformableContactProjection::TVStack*") @ByRef btVector3Array f); + + // update and solve the constraints + public native @Cast("btScalar") float update(@Cast("btCollisionObject**") PointerPointer deformableBodies, int numDeformableBodies, @Const @ByRef btContactSolverInfo infoGlobal); + public native @Cast("btScalar") float update(@ByPtrPtr btCollisionObject deformableBodies, int numDeformableBodies, @Const @ByRef btContactSolverInfo infoGlobal); + + // Add constraints to m_constraints. In addition, the constraints that each vertex own are recorded in m_constraintsDict. + public native void setConstraints(@Const @ByRef btContactSolverInfo infoGlobal); + + // Set up projections for each vertex by adding the projection direction to + public native void setProjection(); + + public native void reinitialize(@Cast("bool") boolean nodeUpdated); + + public native @Cast("btScalar") float solveSplitImpulse(@Cast("btCollisionObject**") PointerPointer deformableBodies, int numDeformableBodies, @Const @ByRef btContactSolverInfo infoGlobal); + public native @Cast("btScalar") float solveSplitImpulse(@ByPtrPtr btCollisionObject deformableBodies, int numDeformableBodies, @Const @ByRef btContactSolverInfo infoGlobal); + + public native void setLagrangeMultiplier(); + + public native void checkConstraints(@Cast("const btDeformableContactProjection::TVStack*") @ByRef btVector3Array x); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableCorotatedForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableCorotatedForce.java new file mode 100644 index 00000000000..5950b019a07 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableCorotatedForce.java @@ -0,0 +1,60 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableCorotatedForce extends btDeformableLagrangianForce { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableCorotatedForce(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableCorotatedForce(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableCorotatedForce position(long position) { + return (btDeformableCorotatedForce)super.position(position); + } + @Override public btDeformableCorotatedForce getPointer(long i) { + return new btDeformableCorotatedForce((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_mu(); public native btDeformableCorotatedForce m_mu(float setter); + public native @Cast("btScalar") float m_lambda(); public native btDeformableCorotatedForce m_lambda(float setter); + public btDeformableCorotatedForce() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btDeformableCorotatedForce(@Cast("btScalar") float mu, @Cast("btScalar") float lambda) { super((Pointer)null); allocate(mu, lambda); } + private native void allocate(@Cast("btScalar") float mu, @Cast("btScalar") float lambda); + + public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledElasticForce(@Cast("btScalar") float scale, @Cast("btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array force); + + public native void firstPiola(@Const @ByRef btMatrix3x3 F, @ByRef btMatrix3x3 P); + + public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array dx, @Cast("btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array df); + + public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array dv, @Cast("btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array df); + + public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableCorotatedForce::TVStack*") @ByRef btVector3Array diagA); + + public native @Cast("btDeformableLagrangianForceType") int getForceType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraint.java new file mode 100644 index 00000000000..9684283558e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraint.java @@ -0,0 +1,65 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// Constraint between deformable objects faces and deformable objects nodes +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableFaceNodeContactConstraint extends btDeformableContactConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableFaceNodeContactConstraint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableFaceNodeContactConstraint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableFaceNodeContactConstraint position(long position) { + return (btDeformableFaceNodeContactConstraint)super.position(position); + } + @Override public btDeformableFaceNodeContactConstraint getPointer(long i) { + return new btDeformableFaceNodeContactConstraint((Pointer)this).offsetAddress(i); + } + + public native btSoftBody.Node m_node(); public native btDeformableFaceNodeContactConstraint m_node(btSoftBody.Node setter); + public native btSoftBody.Face m_face(); public native btDeformableFaceNodeContactConstraint m_face(btSoftBody.Face setter); + public native @Const btSoftBody.DeformableFaceNodeContact m_contact(); public native btDeformableFaceNodeContactConstraint m_contact(btSoftBody.DeformableFaceNodeContact setter); + public native @ByRef btVector3 m_total_normal_dv(); public native btDeformableFaceNodeContactConstraint m_total_normal_dv(btVector3 setter); + public native @ByRef btVector3 m_total_tangent_dv(); public native btDeformableFaceNodeContactConstraint m_total_tangent_dv(btVector3 setter); + + public btDeformableFaceNodeContactConstraint(@Const @ByRef btSoftBody.DeformableFaceNodeContact contact, @Const @ByRef btContactSolverInfo infoGlobal) { super((Pointer)null); allocate(contact, infoGlobal); } + private native void allocate(@Const @ByRef btSoftBody.DeformableFaceNodeContact contact, @Const @ByRef btContactSolverInfo infoGlobal); + public btDeformableFaceNodeContactConstraint() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("btScalar") float solveConstraint(@Const @ByRef btContactSolverInfo infoGlobal); + + // get the velocity of the object A in the contact + public native @ByVal btVector3 getVa(); + + // get the velocity of the object B in the contact + public native @ByVal btVector3 getVb(); + + // get the velocity change of the input soft body node in the constraint + public native @ByVal btVector3 getDv(@Const btSoftBody.Node arg0); + + // cast the contact to the desired type + public native @Const btSoftBody.DeformableFaceNodeContact getContact(); + + public native void applyImpulse(@Const @ByRef btVector3 impulse); + + public native void setPenetrationScale(@Cast("btScalar") float scale); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraintArray.java new file mode 100644 index 00000000000..43895c7eb3b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraintArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableFaceNodeContactConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableFaceNodeContactConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableFaceNodeContactConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableFaceNodeContactConstraintArray position(long position) { + return (btDeformableFaceNodeContactConstraintArray)super.position(position); + } + @Override public btDeformableFaceNodeContactConstraintArray getPointer(long i) { + return new btDeformableFaceNodeContactConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableFaceNodeContactConstraintArray put(@Const @ByRef btDeformableFaceNodeContactConstraintArray other); + public btDeformableFaceNodeContactConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableFaceNodeContactConstraintArray(@Const @ByRef btDeformableFaceNodeContactConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableFaceNodeContactConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableFaceNodeContactConstraint at(int n); + + public native @ByRef @Name("operator []") btDeformableFaceNodeContactConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btDeformableFaceNodeContactConstraint()") btDeformableFaceNodeContactConstraint fillData); + public native void resize(int newsize); + public native @ByRef btDeformableFaceNodeContactConstraint expandNonInitializing(); + + public native @ByRef btDeformableFaceNodeContactConstraint expand(@Const @ByRef(nullValue = "btDeformableFaceNodeContactConstraint()") btDeformableFaceNodeContactConstraint fillValue); + public native @ByRef btDeformableFaceNodeContactConstraint expand(); + + public native void push_back(@Const @ByRef btDeformableFaceNodeContactConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableFaceNodeContactConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraintArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraintArrayArray.java new file mode 100644 index 00000000000..50e29215006 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceNodeContactConstraintArrayArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableFaceNodeContactConstraintArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableFaceNodeContactConstraintArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableFaceNodeContactConstraintArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableFaceNodeContactConstraintArrayArray position(long position) { + return (btDeformableFaceNodeContactConstraintArrayArray)super.position(position); + } + @Override public btDeformableFaceNodeContactConstraintArrayArray getPointer(long i) { + return new btDeformableFaceNodeContactConstraintArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableFaceNodeContactConstraintArrayArray put(@Const @ByRef btDeformableFaceNodeContactConstraintArrayArray other); + public btDeformableFaceNodeContactConstraintArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableFaceNodeContactConstraintArrayArray(@Const @ByRef btDeformableFaceNodeContactConstraintArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableFaceNodeContactConstraintArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableFaceNodeContactConstraintArray at(int n); + + public native @ByRef @Name("operator []") btDeformableFaceNodeContactConstraintArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableFaceNodeContactConstraintArray fillData); + public native void resize(int newsize); + public native @ByRef btDeformableFaceNodeContactConstraintArray expandNonInitializing(); + + public native @ByRef btDeformableFaceNodeContactConstraintArray expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableFaceNodeContactConstraintArray fillValue); + public native @ByRef btDeformableFaceNodeContactConstraintArray expand(); + + public native void push_back(@Const @ByRef btDeformableFaceNodeContactConstraintArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableFaceNodeContactConstraintArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraint.java new file mode 100644 index 00000000000..b9b874ee3e6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraint.java @@ -0,0 +1,61 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// Constraint between rigid/multi body and deformable objects faces +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableFaceRigidContactConstraint extends btDeformableRigidContactConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableFaceRigidContactConstraint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableFaceRigidContactConstraint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableFaceRigidContactConstraint position(long position) { + return (btDeformableFaceRigidContactConstraint)super.position(position); + } + @Override public btDeformableFaceRigidContactConstraint getPointer(long i) { + return new btDeformableFaceRigidContactConstraint((Pointer)this).offsetAddress(i); + } + + public native btSoftBody.Face m_face(); public native btDeformableFaceRigidContactConstraint m_face(btSoftBody.Face setter); + public native @Cast("bool") boolean m_useStrainLimiting(); public native btDeformableFaceRigidContactConstraint m_useStrainLimiting(boolean setter); + public btDeformableFaceRigidContactConstraint(@Const @ByRef btSoftBody.DeformableFaceRigidContact contact, @Const @ByRef btContactSolverInfo infoGlobal, @Cast("bool") boolean useStrainLimiting) { super((Pointer)null); allocate(contact, infoGlobal, useStrainLimiting); } + private native void allocate(@Const @ByRef btSoftBody.DeformableFaceRigidContact contact, @Const @ByRef btContactSolverInfo infoGlobal, @Cast("bool") boolean useStrainLimiting); + public btDeformableFaceRigidContactConstraint(@Const @ByRef btDeformableFaceRigidContactConstraint other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btDeformableFaceRigidContactConstraint other); + public btDeformableFaceRigidContactConstraint() { super((Pointer)null); allocate(); } + private native void allocate(); + + // get the velocity of the deformable face at the contact point + public native @ByVal btVector3 getVb(); + + // get the split impulse velocity of the deformable face at the contact point + public native @ByVal btVector3 getSplitVb(); + + // get the velocity change of the input soft body node in the constraint + public native @ByVal btVector3 getDv(@Const btSoftBody.Node arg0); + + // cast the contact to the desired type + public native @Const btSoftBody.DeformableFaceRigidContact getContact(); + + public native void applyImpulse(@Const @ByRef btVector3 impulse); + + public native void applySplitImpulse(@Const @ByRef btVector3 impulse); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraintArray.java new file mode 100644 index 00000000000..8a877b649fd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraintArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableFaceRigidContactConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableFaceRigidContactConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableFaceRigidContactConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableFaceRigidContactConstraintArray position(long position) { + return (btDeformableFaceRigidContactConstraintArray)super.position(position); + } + @Override public btDeformableFaceRigidContactConstraintArray getPointer(long i) { + return new btDeformableFaceRigidContactConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableFaceRigidContactConstraintArray put(@Const @ByRef btDeformableFaceRigidContactConstraintArray other); + public btDeformableFaceRigidContactConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableFaceRigidContactConstraintArray(@Const @ByRef btDeformableFaceRigidContactConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableFaceRigidContactConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableFaceRigidContactConstraint at(int n); + + public native @ByRef @Name("operator []") btDeformableFaceRigidContactConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btDeformableFaceRigidContactConstraint()") btDeformableFaceRigidContactConstraint fillData); + public native void resize(int newsize); + public native @ByRef btDeformableFaceRigidContactConstraint expandNonInitializing(); + + public native @ByRef btDeformableFaceRigidContactConstraint expand(@Const @ByRef(nullValue = "btDeformableFaceRigidContactConstraint()") btDeformableFaceRigidContactConstraint fillValue); + public native @ByRef btDeformableFaceRigidContactConstraint expand(); + + public native void push_back(@Const @ByRef btDeformableFaceRigidContactConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableFaceRigidContactConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraintArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraintArrayArray.java new file mode 100644 index 00000000000..da40919b7ea --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableFaceRigidContactConstraintArrayArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableFaceRigidContactConstraintArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableFaceRigidContactConstraintArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableFaceRigidContactConstraintArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableFaceRigidContactConstraintArrayArray position(long position) { + return (btDeformableFaceRigidContactConstraintArrayArray)super.position(position); + } + @Override public btDeformableFaceRigidContactConstraintArrayArray getPointer(long i) { + return new btDeformableFaceRigidContactConstraintArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableFaceRigidContactConstraintArrayArray put(@Const @ByRef btDeformableFaceRigidContactConstraintArrayArray other); + public btDeformableFaceRigidContactConstraintArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableFaceRigidContactConstraintArrayArray(@Const @ByRef btDeformableFaceRigidContactConstraintArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableFaceRigidContactConstraintArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableFaceRigidContactConstraintArray at(int n); + + public native @ByRef @Name("operator []") btDeformableFaceRigidContactConstraintArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableFaceRigidContactConstraintArray fillData); + public native void resize(int newsize); + public native @ByRef btDeformableFaceRigidContactConstraintArray expandNonInitializing(); + + public native @ByRef btDeformableFaceRigidContactConstraintArray expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableFaceRigidContactConstraintArray fillValue); + public native @ByRef btDeformableFaceRigidContactConstraintArray expand(); + + public native void push_back(@Const @ByRef btDeformableFaceRigidContactConstraintArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableFaceRigidContactConstraintArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableGravityForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableGravityForce.java new file mode 100644 index 00000000000..a1b1d34c3ec --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableGravityForce.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableGravityForce extends btDeformableLagrangianForce { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableGravityForce(Pointer p) { super(p); } + + public native @ByRef btVector3 m_gravity(); public native btDeformableGravityForce m_gravity(btVector3 setter); + + public btDeformableGravityForce(@Const @ByRef btVector3 g) { super((Pointer)null); allocate(g); } + private native void allocate(@Const @ByRef btVector3 g); + + public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableGravityForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableGravityForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableGravityForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableGravityForce::TVStack*") @ByRef btVector3Array dx, @Cast("btDeformableGravityForce::TVStack*") @ByRef btVector3Array df); + + public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableGravityForce::TVStack*") @ByRef btVector3Array dv, @Cast("btDeformableGravityForce::TVStack*") @ByRef btVector3Array df); + + public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableGravityForce::TVStack*") @ByRef btVector3Array diagA); + + public native void addScaledGravityForce(@Cast("btScalar") float scale, @Cast("btDeformableGravityForce::TVStack*") @ByRef btVector3Array force); + + public native @Cast("btDeformableLagrangianForceType") int getForceType(); + + // the gravitational potential energy + public native double totalEnergy(@Cast("btScalar") float dt); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java index 3f3cad3bcd9..116a55b33a1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForce.java @@ -24,7 +24,7 @@ public class btDeformableLagrangianForce extends Pointer { public btDeformableLagrangianForce(Pointer p) { super(p); } public native @ByRef btSoftBodyArray m_softBodies(); public native btDeformableLagrangianForce m_softBodies(btSoftBodyArray setter); - + public native @Const btSoftBodyNodePointerArray m_nodes(); public native btDeformableLagrangianForce m_nodes(btSoftBodyNodePointerArray setter); // add all forces public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array force); @@ -58,7 +58,7 @@ public class btDeformableLagrangianForce extends Pointer { public native void removeSoftBody(btSoftBody psb); - + public native void setIndices(@Const btSoftBodyNodePointerArray nodes); // Calculate the incremental deformable generated from the input dx public native @ByVal btMatrix3x3 Ds(int id0, int id1, int id2, int id3, @Cast("const btDeformableLagrangianForce::TVStack*") @ByRef btVector3Array dx); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForceArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForceArray.java new file mode 100644 index 00000000000..6e7ac5d8c69 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLagrangianForceArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableLagrangianForceArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableLagrangianForceArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableLagrangianForceArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableLagrangianForceArray position(long position) { + return (btDeformableLagrangianForceArray)super.position(position); + } + @Override public btDeformableLagrangianForceArray getPointer(long i) { + return new btDeformableLagrangianForceArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableLagrangianForceArray put(@Const @ByRef btDeformableLagrangianForceArray other); + public btDeformableLagrangianForceArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableLagrangianForceArray(@Const @ByRef btDeformableLagrangianForceArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableLagrangianForceArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btDeformableLagrangianForce at(int n); + + public native @ByPtrRef @Name("operator []") btDeformableLagrangianForce get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btDeformableLagrangianForce fillData/*=btDeformableLagrangianForce*()*/); + public native void resize(int newsize); + public native @ByPtrRef btDeformableLagrangianForce expandNonInitializing(); + + public native @ByPtrRef btDeformableLagrangianForce expand(@ByPtrRef btDeformableLagrangianForce fillValue/*=btDeformableLagrangianForce*()*/); + public native @ByPtrRef btDeformableLagrangianForce expand(); + + public native void push_back(@ByPtrRef btDeformableLagrangianForce _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btDeformableLagrangianForce key); + + public native int findLinearSearch(@ByPtrRef btDeformableLagrangianForce key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btDeformableLagrangianForce key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btDeformableLagrangianForce key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableLagrangianForceArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLinearElasticityForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLinearElasticityForce.java new file mode 100644 index 00000000000..44f7032775e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableLinearElasticityForce.java @@ -0,0 +1,96 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableLinearElasticityForce extends btDeformableLagrangianForce { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableLinearElasticityForce(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableLinearElasticityForce(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableLinearElasticityForce position(long position) { + return (btDeformableLinearElasticityForce)super.position(position); + } + @Override public btDeformableLinearElasticityForce getPointer(long i) { + return new btDeformableLinearElasticityForce((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_mu(); public native btDeformableLinearElasticityForce m_mu(float setter); + public native @Cast("btScalar") float m_lambda(); public native btDeformableLinearElasticityForce m_lambda(float setter); + public native @Cast("btScalar") float m_E(); public native btDeformableLinearElasticityForce m_E(float setter); + public native @Cast("btScalar") float m_nu(); public native btDeformableLinearElasticityForce m_nu(float setter); // Young's modulus and Poisson ratio + public native @Cast("btScalar") float m_damping_alpha(); public native btDeformableLinearElasticityForce m_damping_alpha(float setter); + public native @Cast("btScalar") float m_damping_beta(); public native btDeformableLinearElasticityForce m_damping_beta(float setter); + public btDeformableLinearElasticityForce() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btDeformableLinearElasticityForce(@Cast("btScalar") float mu, @Cast("btScalar") float lambda, @Cast("btScalar") float damping_alpha/*=0.01*/, @Cast("btScalar") float damping_beta/*=0.01*/) { super((Pointer)null); allocate(mu, lambda, damping_alpha, damping_beta); } + private native void allocate(@Cast("btScalar") float mu, @Cast("btScalar") float lambda, @Cast("btScalar") float damping_alpha/*=0.01*/, @Cast("btScalar") float damping_beta/*=0.01*/); + public btDeformableLinearElasticityForce(@Cast("btScalar") float mu, @Cast("btScalar") float lambda) { super((Pointer)null); allocate(mu, lambda); } + private native void allocate(@Cast("btScalar") float mu, @Cast("btScalar") float lambda); + + public native void updateYoungsModulusAndPoissonRatio(); + + public native void updateLameParameters(); + + public native void setYoungsModulus(@Cast("btScalar") float E); + + public native void setPoissonRatio(@Cast("btScalar") float nu); + + public native void setDamping(@Cast("btScalar") float damping_alpha, @Cast("btScalar") float damping_beta); + + public native void setLameParameters(@Cast("btScalar") float mu, @Cast("btScalar") float lambda); + + public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array force); + + // The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search + public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array force); + + public native double totalElasticEnergy(@Cast("btScalar") float dt); + + // The damping energy is formulated as in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search + public native double totalDampingEnergy(@Cast("btScalar") float dt); + + public native double elasticEnergyDensity(@Const @ByRef btSoftBody.TetraScratch s); + + public native void addScaledElasticForce(@Cast("btScalar") float scale, @Cast("btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array force); + + public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array diagA); + + // The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search + public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array dv, @Cast("btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array df); + + public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array dx, @Cast("btDeformableLinearElasticityForce::TVStack*") @ByRef btVector3Array df); + + public native void firstPiola(@Const @ByRef btSoftBody.TetraScratch s, @ByRef btMatrix3x3 P); + + // Let P be the first piola stress. + // This function calculates the dP = dP/dF * dF + public native void firstPiolaDifferential(@Const @ByRef btSoftBody.TetraScratch s, @Const @ByRef btMatrix3x3 dF, @ByRef btMatrix3x3 dP); + + // Let Q be the damping stress. + // This function calculates the dP = dQ/dF * dF + public native void firstPiolaDampingDifferential(@Const @ByRef btSoftBody.TetraScratch s, @Const @ByRef btMatrix3x3 dF, @ByRef btMatrix3x3 dP); + + public native void addScaledHessian(@Cast("btScalar") float scale); + + public native @Cast("btDeformableLagrangianForceType") int getForceType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMassSpringForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMassSpringForce.java new file mode 100644 index 00000000000..b9d40f4007e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMassSpringForce.java @@ -0,0 +1,61 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableMassSpringForce extends btDeformableLagrangianForce { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableMassSpringForce(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableMassSpringForce(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableMassSpringForce position(long position) { + return (btDeformableMassSpringForce)super.position(position); + } + @Override public btDeformableMassSpringForce getPointer(long i) { + return new btDeformableMassSpringForce((Pointer)this).offsetAddress(i); + } + + public btDeformableMassSpringForce() { super((Pointer)null); allocate(); } + private native void allocate(); + public btDeformableMassSpringForce(@Cast("btScalar") float k, @Cast("btScalar") float d, @Cast("bool") boolean conserve_angular/*=true*/, double bending_k/*=-1*/) { super((Pointer)null); allocate(k, d, conserve_angular, bending_k); } + private native void allocate(@Cast("btScalar") float k, @Cast("btScalar") float d, @Cast("bool") boolean conserve_angular/*=true*/, double bending_k/*=-1*/); + public btDeformableMassSpringForce(@Cast("btScalar") float k, @Cast("btScalar") float d) { super((Pointer)null); allocate(k, d); } + private native void allocate(@Cast("btScalar") float k, @Cast("btScalar") float d); + + public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledElasticForce(@Cast("btScalar") float scale, @Cast("btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array dv, @Cast("btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array df); + + public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array diagA); + + public native double totalElasticEnergy(@Cast("btScalar") float dt); + + public native double totalDampingEnergy(@Cast("btScalar") float dt); + + public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array dx, @Cast("btDeformableMassSpringForce::TVStack*") @ByRef btVector3Array df); + + public native @Cast("btDeformableLagrangianForceType") int getForceType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMousePickingForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMousePickingForce.java new file mode 100644 index 00000000000..622f8f46e63 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMousePickingForce.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableMousePickingForce extends btDeformableLagrangianForce { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableMousePickingForce(Pointer p) { super(p); } + + public btDeformableMousePickingForce(@Cast("btScalar") float k, @Cast("btScalar") float d, @Const @ByRef btSoftBody.Face face, @Const @ByRef btVector3 mouse_pos, @Cast("btScalar") float maxForce/*=0.3*/) { super((Pointer)null); allocate(k, d, face, mouse_pos, maxForce); } + private native void allocate(@Cast("btScalar") float k, @Cast("btScalar") float d, @Const @ByRef btSoftBody.Face face, @Const @ByRef btVector3 mouse_pos, @Cast("btScalar") float maxForce/*=0.3*/); + public btDeformableMousePickingForce(@Cast("btScalar") float k, @Cast("btScalar") float d, @Const @ByRef btSoftBody.Face face, @Const @ByRef btVector3 mouse_pos) { super((Pointer)null); allocate(k, d, face, mouse_pos); } + private native void allocate(@Cast("btScalar") float k, @Cast("btScalar") float d, @Const @ByRef btSoftBody.Face face, @Const @ByRef btVector3 mouse_pos); + + public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledElasticForce(@Cast("btScalar") float scale, @Cast("btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array dv, @Cast("btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array df); + + public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array diagA); + + public native double totalElasticEnergy(@Cast("btScalar") float dt); + + public native double totalDampingEnergy(@Cast("btScalar") float dt); + + public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array dx, @Cast("btDeformableMousePickingForce::TVStack*") @ByRef btVector3Array df); + + public native void setMousePos(@Const @ByRef btVector3 p); + + public native @Cast("btDeformableLagrangianForceType") int getForceType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java index f260da0bf0c..5d4d139fe34 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java @@ -22,7 +22,14 @@ public class btDeformableMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btDeformableMultiBodyDynamicsWorld(Pointer p) { super(p); } - + public static class btSolverCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSolverCallback(Pointer p) { super(p); } + protected btSolverCallback() { allocate(); } + private native void allocate(); + public native void call(@Cast("btScalar") float time, btDeformableMultiBodyDynamicsWorld world); +} public btDeformableMultiBodyDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btDeformableMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btDeformableBodySolver deformableBodySolver/*=0*/) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration, deformableBodySolver); } private native void allocate(btDispatcher dispatcher, btBroadphaseInterface pairCache, btDeformableMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration, btDeformableBodySolver deformableBodySolver/*=0*/); public btDeformableMultiBodyDynamicsWorld(btDispatcher dispatcher, btBroadphaseInterface pairCache, btDeformableMultiBodyConstraintSolver constraintSolver, btCollisionConfiguration collisionConfiguration) { super((Pointer)null); allocate(dispatcher, pairCache, constraintSolver, collisionConfiguration); } @@ -33,7 +40,7 @@ public class btDeformableMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld public native void debugDrawWorld(); - + public native void setSolverCallback(btSolverCallback cb); public native btMultiBodyDynamicsWorld getMultiBodyDynamicsWorld(); @@ -73,7 +80,7 @@ public class btDeformableMultiBodyDynamicsWorld extends btMultiBodyDynamicsWorld public native void performDeformableCollisionDetection(); - + public native void solveMultiBodyConstraints(); public native void solveContactConstraints(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNeoHookeanForce.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNeoHookeanForce.java new file mode 100644 index 00000000000..ac150d6ac3f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNeoHookeanForce.java @@ -0,0 +1,102 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +// This energy is as described in https://graphics.pixar.com/library/StableElasticity/paper.pdf +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableNeoHookeanForce extends btDeformableLagrangianForce { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableNeoHookeanForce(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableNeoHookeanForce(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableNeoHookeanForce position(long position) { + return (btDeformableNeoHookeanForce)super.position(position); + } + @Override public btDeformableNeoHookeanForce getPointer(long i) { + return new btDeformableNeoHookeanForce((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float m_mu(); public native btDeformableNeoHookeanForce m_mu(float setter); + public native @Cast("btScalar") float m_lambda(); public native btDeformableNeoHookeanForce m_lambda(float setter); // Lame Parameters + public native @Cast("btScalar") float m_E(); public native btDeformableNeoHookeanForce m_E(float setter); + public native @Cast("btScalar") float m_nu(); public native btDeformableNeoHookeanForce m_nu(float setter); // Young's modulus and Poisson ratio + public native @Cast("btScalar") float m_mu_damp(); public native btDeformableNeoHookeanForce m_mu_damp(float setter); + public native @Cast("btScalar") float m_lambda_damp(); public native btDeformableNeoHookeanForce m_lambda_damp(float setter); + public btDeformableNeoHookeanForce() { super((Pointer)null); allocate(); } + private native void allocate(); + + public btDeformableNeoHookeanForce(@Cast("btScalar") float mu, @Cast("btScalar") float lambda, @Cast("btScalar") float damping/*=0.05*/) { super((Pointer)null); allocate(mu, lambda, damping); } + private native void allocate(@Cast("btScalar") float mu, @Cast("btScalar") float lambda, @Cast("btScalar") float damping/*=0.05*/); + public btDeformableNeoHookeanForce(@Cast("btScalar") float mu, @Cast("btScalar") float lambda) { super((Pointer)null); allocate(mu, lambda); } + private native void allocate(@Cast("btScalar") float mu, @Cast("btScalar") float lambda); + + public native void updateYoungsModulusAndPoissonRatio(); + + public native void updateLameParameters(); + + public native void setYoungsModulus(@Cast("btScalar") float E); + + public native void setPoissonRatio(@Cast("btScalar") float nu); + + public native void setDamping(@Cast("btScalar") float damping); + + public native void setLameParameters(@Cast("btScalar") float mu, @Cast("btScalar") float lambda); + + public native void addScaledForces(@Cast("btScalar") float scale, @Cast("btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array force); + + public native void addScaledExplicitForce(@Cast("btScalar") float scale, @Cast("btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array force); + + // The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search + public native void addScaledDampingForce(@Cast("btScalar") float scale, @Cast("btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array force); + + public native double totalElasticEnergy(@Cast("btScalar") float dt); + + // The damping energy is formulated as in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search + public native double totalDampingEnergy(@Cast("btScalar") float dt); + + public native double elasticEnergyDensity(@Const @ByRef btSoftBody.TetraScratch s); + + public native void addScaledElasticForce(@Cast("btScalar") float scale, @Cast("btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array force); + + // The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search + public native void addScaledDampingForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array dv, @Cast("btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array df); + + public native void buildDampingForceDifferentialDiagonal(@Cast("btScalar") float scale, @Cast("btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array diagA); + + public native void addScaledElasticForceDifferential(@Cast("btScalar") float scale, @Cast("const btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array dx, @Cast("btDeformableNeoHookeanForce::TVStack*") @ByRef btVector3Array df); + + public native void firstPiola(@Const @ByRef btSoftBody.TetraScratch s, @ByRef btMatrix3x3 P); + + // Let P be the first piola stress. + // This function calculates the dP = dP/dF * dF + public native void firstPiolaDifferential(@Const @ByRef btSoftBody.TetraScratch s, @Const @ByRef btMatrix3x3 dF, @ByRef btMatrix3x3 dP); + + // Let Q be the damping stress. + // This function calculates the dP = dQ/dF * dF + public native void firstPiolaDampingDifferential(@Const @ByRef btSoftBody.TetraScratch s, @Const @ByRef btMatrix3x3 dF, @ByRef btMatrix3x3 dP); + + public native @Cast("btScalar") float DotProduct(@Const @ByRef btMatrix3x3 A, @Const @ByRef btMatrix3x3 B); + + // Let C(A) be the cofactor of the matrix A + // Let H = the derivative of C(A) with respect to A evaluated at F = A + // This function calculates H*dF + public native void addScaledCofactorMatrixDifferential(@Const @ByRef btMatrix3x3 F, @Const @ByRef btMatrix3x3 dF, @Cast("btScalar") float scale, @ByRef btMatrix3x3 M); + + public native @Cast("btDeformableLagrangianForceType") int getForceType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraint.java new file mode 100644 index 00000000000..5f1cb4c8a19 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraint.java @@ -0,0 +1,55 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// Anchor Constraint between rigid and deformable node +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableNodeAnchorConstraint extends btDeformableContactConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableNodeAnchorConstraint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableNodeAnchorConstraint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableNodeAnchorConstraint position(long position) { + return (btDeformableNodeAnchorConstraint)super.position(position); + } + @Override public btDeformableNodeAnchorConstraint getPointer(long i) { + return new btDeformableNodeAnchorConstraint((Pointer)this).offsetAddress(i); + } + + public native @Const btSoftBody.DeformableNodeRigidAnchor m_anchor(); public native btDeformableNodeAnchorConstraint m_anchor(btSoftBody.DeformableNodeRigidAnchor setter); + + public btDeformableNodeAnchorConstraint(@Const @ByRef btSoftBody.DeformableNodeRigidAnchor c, @Const @ByRef btContactSolverInfo infoGlobal) { super((Pointer)null); allocate(c, infoGlobal); } + private native void allocate(@Const @ByRef btSoftBody.DeformableNodeRigidAnchor c, @Const @ByRef btContactSolverInfo infoGlobal); + public btDeformableNodeAnchorConstraint(@Const @ByRef btDeformableNodeAnchorConstraint other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btDeformableNodeAnchorConstraint other); + public btDeformableNodeAnchorConstraint() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("btScalar") float solveConstraint(@Const @ByRef btContactSolverInfo infoGlobal); + + // object A is the rigid/multi body, and object B is the deformable node/face + public native @ByVal btVector3 getVa(); + // get the velocity of the deformable node in contact + public native @ByVal btVector3 getVb(); + public native @ByVal btVector3 getDv(@Const btSoftBody.Node n); + public native void applyImpulse(@Const @ByRef btVector3 impulse); + + public native void setPenetrationScale(@Cast("btScalar") float scale); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraintArray.java new file mode 100644 index 00000000000..b2ec7413b5b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraintArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableNodeAnchorConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableNodeAnchorConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableNodeAnchorConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableNodeAnchorConstraintArray position(long position) { + return (btDeformableNodeAnchorConstraintArray)super.position(position); + } + @Override public btDeformableNodeAnchorConstraintArray getPointer(long i) { + return new btDeformableNodeAnchorConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableNodeAnchorConstraintArray put(@Const @ByRef btDeformableNodeAnchorConstraintArray other); + public btDeformableNodeAnchorConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableNodeAnchorConstraintArray(@Const @ByRef btDeformableNodeAnchorConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableNodeAnchorConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableNodeAnchorConstraint at(int n); + + public native @ByRef @Name("operator []") btDeformableNodeAnchorConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btDeformableNodeAnchorConstraint()") btDeformableNodeAnchorConstraint fillData); + public native void resize(int newsize); + public native @ByRef btDeformableNodeAnchorConstraint expandNonInitializing(); + + public native @ByRef btDeformableNodeAnchorConstraint expand(@Const @ByRef(nullValue = "btDeformableNodeAnchorConstraint()") btDeformableNodeAnchorConstraint fillValue); + public native @ByRef btDeformableNodeAnchorConstraint expand(); + + public native void push_back(@Const @ByRef btDeformableNodeAnchorConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableNodeAnchorConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraintArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraintArrayArray.java new file mode 100644 index 00000000000..1df53c73388 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeAnchorConstraintArrayArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableNodeAnchorConstraintArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableNodeAnchorConstraintArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableNodeAnchorConstraintArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableNodeAnchorConstraintArrayArray position(long position) { + return (btDeformableNodeAnchorConstraintArrayArray)super.position(position); + } + @Override public btDeformableNodeAnchorConstraintArrayArray getPointer(long i) { + return new btDeformableNodeAnchorConstraintArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableNodeAnchorConstraintArrayArray put(@Const @ByRef btDeformableNodeAnchorConstraintArrayArray other); + public btDeformableNodeAnchorConstraintArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableNodeAnchorConstraintArrayArray(@Const @ByRef btDeformableNodeAnchorConstraintArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableNodeAnchorConstraintArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableNodeAnchorConstraintArray at(int n); + + public native @ByRef @Name("operator []") btDeformableNodeAnchorConstraintArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableNodeAnchorConstraintArray fillData); + public native void resize(int newsize); + public native @ByRef btDeformableNodeAnchorConstraintArray expandNonInitializing(); + + public native @ByRef btDeformableNodeAnchorConstraintArray expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableNodeAnchorConstraintArray fillValue); + public native @ByRef btDeformableNodeAnchorConstraintArray expand(); + + public native void push_back(@Const @ByRef btDeformableNodeAnchorConstraintArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableNodeAnchorConstraintArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraint.java new file mode 100644 index 00000000000..f8fa8321dd0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraint.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// Constraint between rigid/multi body and deformable objects nodes +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableNodeRigidContactConstraint extends btDeformableRigidContactConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableNodeRigidContactConstraint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableNodeRigidContactConstraint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableNodeRigidContactConstraint position(long position) { + return (btDeformableNodeRigidContactConstraint)super.position(position); + } + @Override public btDeformableNodeRigidContactConstraint getPointer(long i) { + return new btDeformableNodeRigidContactConstraint((Pointer)this).offsetAddress(i); + } + + // the deformable node in contact + public native btSoftBody.Node m_node(); public native btDeformableNodeRigidContactConstraint m_node(btSoftBody.Node setter); + + public btDeformableNodeRigidContactConstraint(@Const @ByRef btSoftBody.DeformableNodeRigidContact contact, @Const @ByRef btContactSolverInfo infoGlobal) { super((Pointer)null); allocate(contact, infoGlobal); } + private native void allocate(@Const @ByRef btSoftBody.DeformableNodeRigidContact contact, @Const @ByRef btContactSolverInfo infoGlobal); + public btDeformableNodeRigidContactConstraint(@Const @ByRef btDeformableNodeRigidContactConstraint other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btDeformableNodeRigidContactConstraint other); + public btDeformableNodeRigidContactConstraint() { super((Pointer)null); allocate(); } + private native void allocate(); + + // get the velocity of the deformable node in contact + public native @ByVal btVector3 getVb(); + + // get the split impulse velocity of the deformable face at the contact point + public native @ByVal btVector3 getSplitVb(); + + // get the velocity change of the input soft body node in the constraint + public native @ByVal btVector3 getDv(@Const btSoftBody.Node arg0); + + // cast the contact to the desired type + public native @Const btSoftBody.DeformableNodeRigidContact getContact(); + + public native void applyImpulse(@Const @ByRef btVector3 impulse); + + public native void applySplitImpulse(@Const @ByRef btVector3 impulse); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraintArray.java new file mode 100644 index 00000000000..11b2571bf14 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraintArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableNodeRigidContactConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableNodeRigidContactConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableNodeRigidContactConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableNodeRigidContactConstraintArray position(long position) { + return (btDeformableNodeRigidContactConstraintArray)super.position(position); + } + @Override public btDeformableNodeRigidContactConstraintArray getPointer(long i) { + return new btDeformableNodeRigidContactConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableNodeRigidContactConstraintArray put(@Const @ByRef btDeformableNodeRigidContactConstraintArray other); + public btDeformableNodeRigidContactConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableNodeRigidContactConstraintArray(@Const @ByRef btDeformableNodeRigidContactConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableNodeRigidContactConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableNodeRigidContactConstraint at(int n); + + public native @ByRef @Name("operator []") btDeformableNodeRigidContactConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btDeformableNodeRigidContactConstraint()") btDeformableNodeRigidContactConstraint fillData); + public native void resize(int newsize); + public native @ByRef btDeformableNodeRigidContactConstraint expandNonInitializing(); + + public native @ByRef btDeformableNodeRigidContactConstraint expand(@Const @ByRef(nullValue = "btDeformableNodeRigidContactConstraint()") btDeformableNodeRigidContactConstraint fillValue); + public native @ByRef btDeformableNodeRigidContactConstraint expand(); + + public native void push_back(@Const @ByRef btDeformableNodeRigidContactConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableNodeRigidContactConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraintArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraintArrayArray.java new file mode 100644 index 00000000000..4afabfadc14 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableNodeRigidContactConstraintArrayArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableNodeRigidContactConstraintArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableNodeRigidContactConstraintArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableNodeRigidContactConstraintArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableNodeRigidContactConstraintArrayArray position(long position) { + return (btDeformableNodeRigidContactConstraintArrayArray)super.position(position); + } + @Override public btDeformableNodeRigidContactConstraintArrayArray getPointer(long i) { + return new btDeformableNodeRigidContactConstraintArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableNodeRigidContactConstraintArrayArray put(@Const @ByRef btDeformableNodeRigidContactConstraintArrayArray other); + public btDeformableNodeRigidContactConstraintArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableNodeRigidContactConstraintArrayArray(@Const @ByRef btDeformableNodeRigidContactConstraintArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableNodeRigidContactConstraintArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableNodeRigidContactConstraintArray at(int n); + + public native @ByRef @Name("operator []") btDeformableNodeRigidContactConstraintArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableNodeRigidContactConstraintArray fillData); + public native void resize(int newsize); + public native @ByRef btDeformableNodeRigidContactConstraintArray expandNonInitializing(); + + public native @ByRef btDeformableNodeRigidContactConstraintArray expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableNodeRigidContactConstraintArray fillValue); + public native @ByRef btDeformableNodeRigidContactConstraintArray expand(); + + public native void push_back(@Const @ByRef btDeformableNodeRigidContactConstraintArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableNodeRigidContactConstraintArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableRigidContactConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableRigidContactConstraint.java new file mode 100644 index 00000000000..520c8e87915 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableRigidContactConstraint.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// Constraint between rigid/multi body and deformable objects +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableRigidContactConstraint extends btDeformableContactConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableRigidContactConstraint(Pointer p) { super(p); } + + public native @ByRef btVector3 m_total_normal_dv(); public native btDeformableRigidContactConstraint m_total_normal_dv(btVector3 setter); + public native @ByRef btVector3 m_total_tangent_dv(); public native btDeformableRigidContactConstraint m_total_tangent_dv(btVector3 setter); + public native @Cast("btScalar") float m_penetration(); public native btDeformableRigidContactConstraint m_penetration(float setter); + public native @Cast("btScalar") float m_total_split_impulse(); public native btDeformableRigidContactConstraint m_total_split_impulse(float setter); + public native @Cast("bool") boolean m_binding(); public native btDeformableRigidContactConstraint m_binding(boolean setter); + public native @Const btSoftBody.DeformableRigidContact m_contact(); public native btDeformableRigidContactConstraint m_contact(btSoftBody.DeformableRigidContact setter); + + // object A is the rigid/multi body, and object B is the deformable node/face + public native @ByVal btVector3 getVa(); + + // get the split impulse velocity of the deformable face at the contact point + public native @ByVal btVector3 getSplitVb(); + + // get the split impulse velocity of the rigid/multibdoy at the contaft + public native @ByVal btVector3 getSplitVa(); + + public native @Cast("btScalar") float solveConstraint(@Const @ByRef btContactSolverInfo infoGlobal); + + public native void setPenetrationScale(@Cast("btScalar") float scale); + + public native @Cast("btScalar") float solveSplitImpulse(@Const @ByRef btContactSolverInfo infoGlobal); + + public native void applySplitImpulse(@Const @ByRef btVector3 impulse); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraint.java new file mode 100644 index 00000000000..52212847c7f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraint.java @@ -0,0 +1,56 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// Constraint that a certain node in the deformable objects cannot move +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableStaticConstraint extends btDeformableContactConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableStaticConstraint(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableStaticConstraint(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableStaticConstraint position(long position) { + return (btDeformableStaticConstraint)super.position(position); + } + @Override public btDeformableStaticConstraint getPointer(long i) { + return new btDeformableStaticConstraint((Pointer)this).offsetAddress(i); + } + + public native btSoftBody.Node m_node(); public native btDeformableStaticConstraint m_node(btSoftBody.Node setter); + + public btDeformableStaticConstraint(btSoftBody.Node node, @Const @ByRef btContactSolverInfo infoGlobal) { super((Pointer)null); allocate(node, infoGlobal); } + private native void allocate(btSoftBody.Node node, @Const @ByRef btContactSolverInfo infoGlobal); + public btDeformableStaticConstraint() { super((Pointer)null); allocate(); } + private native void allocate(); + public btDeformableStaticConstraint(@Const @ByRef btDeformableStaticConstraint other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef btDeformableStaticConstraint other); + + public native @Cast("btScalar") float solveConstraint(@Const @ByRef btContactSolverInfo infoGlobal); + + public native @ByVal btVector3 getVa(); + + public native @ByVal btVector3 getVb(); + + public native @ByVal btVector3 getDv(@Const btSoftBody.Node n); + + public native void applyImpulse(@Const @ByRef btVector3 impulse); + public native void setPenetrationScale(@Cast("btScalar") float scale); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraintArray.java new file mode 100644 index 00000000000..dd3e3aa137a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraintArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableStaticConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableStaticConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableStaticConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableStaticConstraintArray position(long position) { + return (btDeformableStaticConstraintArray)super.position(position); + } + @Override public btDeformableStaticConstraintArray getPointer(long i) { + return new btDeformableStaticConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableStaticConstraintArray put(@Const @ByRef btDeformableStaticConstraintArray other); + public btDeformableStaticConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableStaticConstraintArray(@Const @ByRef btDeformableStaticConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableStaticConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableStaticConstraint at(int n); + + public native @ByRef @Name("operator []") btDeformableStaticConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btDeformableStaticConstraint()") btDeformableStaticConstraint fillData); + public native void resize(int newsize); + public native @ByRef btDeformableStaticConstraint expandNonInitializing(); + + public native @ByRef btDeformableStaticConstraint expand(@Const @ByRef(nullValue = "btDeformableStaticConstraint()") btDeformableStaticConstraint fillValue); + public native @ByRef btDeformableStaticConstraint expand(); + + public native void push_back(@Const @ByRef btDeformableStaticConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableStaticConstraintArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraintArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraintArrayArray.java new file mode 100644 index 00000000000..104856209ec --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableStaticConstraintArrayArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray >") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btDeformableStaticConstraintArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btDeformableStaticConstraintArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btDeformableStaticConstraintArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btDeformableStaticConstraintArrayArray position(long position) { + return (btDeformableStaticConstraintArrayArray)super.position(position); + } + @Override public btDeformableStaticConstraintArrayArray getPointer(long i) { + return new btDeformableStaticConstraintArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btDeformableStaticConstraintArrayArray put(@Const @ByRef btDeformableStaticConstraintArrayArray other); + public btDeformableStaticConstraintArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btDeformableStaticConstraintArrayArray(@Const @ByRef btDeformableStaticConstraintArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btDeformableStaticConstraintArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btDeformableStaticConstraintArray at(int n); + + public native @ByRef @Name("operator []") btDeformableStaticConstraintArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableStaticConstraintArray fillData); + public native void resize(int newsize); + public native @ByRef btDeformableStaticConstraintArray expandNonInitializing(); + + public native @ByRef btDeformableStaticConstraintArray expand(@Const @ByRef(nullValue = "btAlignedObjectArray()") btDeformableStaticConstraintArray fillValue); + public native @ByRef btDeformableStaticConstraintArray expand(); + + public native void push_back(@Const @ByRef btDeformableStaticConstraintArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btDeformableStaticConstraintArrayArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btEigen.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btEigen.java new file mode 100644 index 00000000000..b08bf6a4100 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btEigen.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// btEigen : Extract eigen system, +// straitforward implementation of http://math.fullerton.edu/mathews/n2003/JacobiMethodMod.html +// outputs are NOT sorted. +// +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btEigen extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btEigen() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btEigen(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btEigen(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btEigen position(long position) { + return (btEigen)super.position(position); + } + @Override public btEigen getPointer(long i) { + return new btEigen((Pointer)this).offsetAddress(i); + } + + public static native int system(@ByRef btMatrix3x3 a, btMatrix3x3 vectors, btVector3 values/*=0*/); + public static native int system(@ByRef btMatrix3x3 a, btMatrix3x3 vectors); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java index 30589eff54a..bf55872ff37 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBody.java @@ -65,8 +65,55 @@ public static class eAeroModel extends Pointer { } /**eVSolver : velocities solvers */ + public static class eVSolver extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public eVSolver() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public eVSolver(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public eVSolver(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public eVSolver position(long position) { + return (eVSolver)super.position(position); + } + @Override public eVSolver getPointer(long i) { + return new eVSolver((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::eVSolver::_ */ + public static final int + Linear = 0, /**Linear solver */ + END = 1; + } /**ePSolver : positions solvers */ + public static class ePSolver extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public ePSolver() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public ePSolver(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ePSolver(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public ePSolver position(long position) { + return (ePSolver)super.position(position); + } + @Override public ePSolver getPointer(long i) { + return new ePSolver((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::ePSolver::_ */ + public static final int + Linear = 0, /**Linear solver */ + Anchors = 1, /**Anchor solver */ + RContacts = 2, /**Rigid contacts solver */ + SContacts = 3, /**Soft contacts solver */ + END = 4; + } /**eSolverPresets */ public static class eSolverPresets extends Pointer { @@ -127,8 +174,70 @@ public static class eFeature extends Pointer { // /**fCollision */ + public static class fCollision extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public fCollision() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public fCollision(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public fCollision(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public fCollision position(long position) { + return (fCollision)super.position(position); + } + @Override public fCollision getPointer(long i) { + return new fCollision((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::fCollision::_ */ + public static final int + RVSmask = 0x000f, /**Rigid versus soft mask */ + SDF_RS = 0x0001, /**SDF based rigid vs soft */ + CL_RS = 0x0002, /**Cluster vs convex rigid vs soft */ + SDF_RD = 0x0004, /**rigid vs deformable */ + + SVSmask = 0x00f0, /**Rigid versus soft mask */ + VF_SS = 0x0010, /**Vertex vs face soft vs soft handling */ + CL_SS = 0x0020, /**Cluster vs cluster soft vs soft handling */ + CL_SELF = 0x0040, /**Cluster soft body self collision */ + VF_DD = 0x0080, /**Vertex vs face soft vs soft handling */ + + RVDFmask = 0x0f00, /** Rigid versus deformable face mask */ + SDF_RDF = 0x0100, /** GJK based Rigid vs. deformable face */ + SDF_MDF = 0x0200, /** GJK based Multibody vs. deformable face */ + SDF_RDN = 0x0400, /** SDF based Rigid vs. deformable node */ + /* presets */ + Default = SDF_RS, + END = SDF_RS + 1; + } /**fMaterial */ + public static class fMaterial extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public fMaterial() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public fMaterial(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public fMaterial(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public fMaterial position(long position) { + return (fMaterial)super.position(position); + } + @Override public fMaterial getPointer(long i) { + return new fMaterial((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::fMaterial::_ */ + public static final int + DebugDraw = 0x0001, /** Enable debug draw */ + /* presets */ + Default = DebugDraw, + END = DebugDraw + 1; + } // // API Types @@ -328,7 +437,7 @@ public static class RenderNode extends Pointer { public native @ByRef btVector3 m_n(); public native Node m_n(btVector3 setter); // Normal public native @Cast("btScalar") float m_im(); public native Node m_im(float setter); // 1/mass public native @Cast("btScalar") float m_area(); public native Node m_area(float setter); // Area - // Leaf data + public native btDbvtNode m_leaf(); public native Node m_leaf(btDbvtNode setter); // Leaf data public native int m_constrained(); public native Node m_constrained(int setter); // depth of penetration public native @NoOffset int m_battach(); public native Node m_battach(int setter); // Attached public native int index(); public native Node index(int setter); @@ -406,7 +515,7 @@ public static class RenderFace extends Pointer { @MemberGetter public native @Cast("btSoftBody::Node**") PointerPointer m_n(); // Node pointers public native @ByRef btVector3 m_normal(); public native Face m_normal(btVector3 setter); // Normal public native @Cast("btScalar") float m_ra(); public native Face m_ra(float setter); // Rest area - // Leaf data + public native btDbvtNode m_leaf(); public native Face m_leaf(btDbvtNode setter); // Leaf data public native @ByRef btVector4 m_pcontact(); public native Face m_pcontact(btVector4 setter); // barycentric weights of the persistent contact public native @ByRef btVector3 m_n0(); public native Face m_n0(btVector3 setter); public native @ByRef btVector3 m_n1(); public native Face m_n1(btVector3 setter); @@ -434,7 +543,7 @@ public static class RenderFace extends Pointer { public native Node m_n(int i); public native Tetra m_n(int i, Node setter); @MemberGetter public native @Cast("btSoftBody::Node**") PointerPointer m_n(); // Node pointers public native @Cast("btScalar") float m_rv(); public native Tetra m_rv(float setter); // Rest volume - // Leaf data + public native btDbvtNode m_leaf(); public native Tetra m_leaf(btDbvtNode setter); // Leaf data public native @ByRef btVector3 m_c0(int i); public native Tetra m_c0(int i, btVector3 setter); @MemberGetter public native btVector3 m_c0(); // gradients public native @Cast("btScalar") float m_c1(); public native Tetra m_c1(float setter); // (4*kVST)/(im0+im1+im2+im3) @@ -752,7 +861,7 @@ public static class Pose extends Pointer { } public native @ByRef @Cast("btSoftBody::tScalarArray*") btScalarArray m_masses(); public native Cluster m_masses(btScalarArray setter); - + public native @ByRef btSoftBodyNodePointerArray m_nodes(); public native Cluster m_nodes(btSoftBodyNodePointerArray setter); public native @ByRef @Cast("btSoftBody::tVector3Array*") btVector3Array m_framerefs(); public native Cluster m_framerefs(btVector3Array setter); public native @ByRef btTransform m_framexform(); public native Cluster m_framexform(btTransform setter); public native @Cast("btScalar") float m_idmass(); public native Cluster m_idmass(float setter); @@ -768,7 +877,7 @@ public static class Pose extends Pointer { public native int m_ndimpulses(); public native Cluster m_ndimpulses(int setter); public native @ByRef btVector3 m_lv(); public native Cluster m_lv(btVector3 setter); public native @ByRef btVector3 m_av(); public native Cluster m_av(btVector3 setter); - + public native btDbvtNode m_leaf(); public native Cluster m_leaf(btDbvtNode setter); public native @Cast("btScalar") float m_ndamping(); public native Cluster m_ndamping(float setter); /* Node damping */ public native @Cast("btScalar") float m_ldamping(); public native Cluster m_ldamping(float setter); /* Linear damping */ public native @Cast("btScalar") float m_adamping(); public native Cluster m_adamping(float setter); /* Angular damping */ @@ -853,6 +962,29 @@ public static class Pose extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public Joint(Pointer p) { super(p); } + public static class eType extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public eType() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public eType(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public eType(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public eType position(long position) { + return (eType)super.position(position); + } + @Override public eType getPointer(long i) { + return new eType((Pointer)this).offsetAddress(i); + } + + /** enum btSoftBody::Joint::eType::_ */ + public static final int + Linear = 0, + Angular = 1, + Contact = 2; + } @NoOffset public static class Specs extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ @@ -887,6 +1019,7 @@ public static class Pose extends Pointer { public native void Prepare(@Cast("btScalar") float dt, int iterations); public native void Solve(@Cast("btScalar") float dt, @Cast("btScalar") float sor); public native void Terminate(@Cast("btScalar") float dt); + public native @Cast("btSoftBody::Joint::eType::_") int Type(); } /* LJoint */ @NoOffset public static class LJoint extends Joint { @@ -1070,7 +1203,10 @@ public static class Config extends Pointer { public native int piterations(); public native Config piterations(int setter); // Positions solver iterations public native int diterations(); public native Config diterations(int setter); // Drift solver iterations public native int citerations(); public native Config citerations(int setter); // Cluster solver iterations - public native int collisions(); public native Config collisions(int setter); // Collisions flags // Velocity solvers sequence // Position solvers sequence // Drift solvers sequence + public native int collisions(); public native Config collisions(int setter); // Collisions flags + public native @ByRef @Cast("btSoftBody::tVSolverArray*") LagrangeMultiplierArray m_vsequence(); public native Config m_vsequence(LagrangeMultiplierArray setter); // Velocity solvers sequence + public native @ByRef @Cast("btSoftBody::tPSolverArray*") LagrangeMultiplierArray m_psequence(); public native Config m_psequence(LagrangeMultiplierArray setter); // Position solvers sequence + public native @ByRef @Cast("btSoftBody::tPSolverArray*") LagrangeMultiplierArray m_dsequence(); public native Config m_dsequence(LagrangeMultiplierArray setter); // Drift solvers sequence public native @Cast("btScalar") float drag(); public native Config drag(float setter); // deformable air drag public native @Cast("btScalar") float m_maxStress(); public native Config m_maxStress(float setter); // Maximum principle first Piola stress } @@ -1099,6 +1235,35 @@ public static class Config extends Pointer { public native @Cast("btScalar") float updmrg(); public native SolverState updmrg(float setter); // Update margin } /** RayFromToCaster takes a ray from, ray to (instead of direction!) */ + @NoOffset public static class RayFromToCaster extends btDbvt.ICollide { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public RayFromToCaster(Pointer p) { super(p); } + + public native @ByRef btVector3 m_rayFrom(); public native RayFromToCaster m_rayFrom(btVector3 setter); + public native @ByRef btVector3 m_rayTo(); public native RayFromToCaster m_rayTo(btVector3 setter); + public native @ByRef btVector3 m_rayNormalizedDirection(); public native RayFromToCaster m_rayNormalizedDirection(btVector3 setter); + public native @Cast("btScalar") float m_mint(); public native RayFromToCaster m_mint(float setter); + public native Face m_face(); public native RayFromToCaster m_face(Face setter); + public native int m_tests(); public native RayFromToCaster m_tests(int setter); + public RayFromToCaster(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @Cast("btScalar") float mxt) { super((Pointer)null); allocate(rayFrom, rayTo, mxt); } + private native void allocate(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVector3 rayTo, @Cast("btScalar") float mxt); + public native void Process(@Const btDbvtNode leaf); + + public static native @Cast("btScalar") float rayFromToTriangle(@Const @ByRef btVector3 rayFrom, + @Const @ByRef btVector3 rayTo, + @Const @ByRef btVector3 rayNormalizedDirection, + @Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @Const @ByRef btVector3 c, + @Cast("btScalar") float maxt/*=SIMD_INFINITY*/); + public static native @Cast("btScalar") float rayFromToTriangle(@Const @ByRef btVector3 rayFrom, + @Const @ByRef btVector3 rayTo, + @Const @ByRef btVector3 rayNormalizedDirection, + @Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @Const @ByRef btVector3 c); + } // // Typedefs @@ -1137,14 +1302,14 @@ public static class vsolver_t extends FunctionPointer { public native @ByRef @Cast("btSoftBody::tFaceArray*") btSoftBodyFaceArray m_faces(); public native btSoftBody m_faces(btSoftBodyFaceArray setter); // Faces public native @ByRef @Cast("btSoftBody::tRenderFaceArray*") btSoftBodyRenderFaceArray m_renderFaces(); public native btSoftBody m_renderFaces(btSoftBodyRenderFaceArray setter); // Faces public native @ByRef @Cast("btSoftBody::tTetraArray*") btSoftBodyTetraArray m_tetras(); public native btSoftBody m_tetras(btSoftBodyTetraArray setter); // Tetras - - + public native @ByRef btSoftBodyTetraSratchArray m_tetraScratches(); public native btSoftBody m_tetraScratches(btSoftBodyTetraSratchArray setter); + public native @ByRef btSoftBodyTetraSratchArray m_tetraScratchesTn(); public native btSoftBody m_tetraScratchesTn(btSoftBodyTetraSratchArray setter); public native @ByRef @Cast("btSoftBody::tAnchorArray*") btSoftBodyAnchorArray m_anchors(); public native btSoftBody m_anchors(btSoftBodyAnchorArray setter); // Anchors - + public native @ByRef btSoftBodyDeformableNodeRigidAnchorArray m_deformableAnchors(); public native btSoftBody m_deformableAnchors(btSoftBodyDeformableNodeRigidAnchorArray setter); public native @ByRef @Cast("btSoftBody::tRContactArray*") btSoftBodyRContactArray m_rcontacts(); public native btSoftBody m_rcontacts(btSoftBodyRContactArray setter); // Rigid contacts - - - + public native @ByRef btSoftBodyDeformableNodeRigidContactArray m_nodeRigidContacts(); public native btSoftBody m_nodeRigidContacts(btSoftBodyDeformableNodeRigidContactArray setter); + public native @ByRef btSoftBodyDeformableFaceNodeContactArray m_faceNodeContacts(); public native btSoftBody m_faceNodeContacts(btSoftBodyDeformableFaceNodeContactArray setter); + public native @ByRef btSoftBodyDeformableFaceRigidContactArray m_faceRigidContacts(); public native btSoftBody m_faceRigidContacts(btSoftBodyDeformableFaceRigidContactArray setter); public native @ByRef @Cast("btSoftBody::tSContactArray*") btSoftBodySContactArray m_scontacts(); public native btSoftBody m_scontacts(btSoftBodySContactArray setter); // Soft contacts public native @ByRef @Cast("btSoftBody::tJointArray*") btSoftBodyJointArray m_joints(); public native btSoftBody m_joints(btSoftBodyJointArray setter); // Joints public native @ByRef @Cast("btSoftBody::tMaterialArray*") btSoftBodyMaterialArray m_materials(); public native btSoftBody m_materials(btSoftBodyMaterialArray setter); // Materials @@ -1154,7 +1319,7 @@ public static class vsolver_t extends FunctionPointer { public native @Cast("bool") boolean m_bUpdateRtCst(); public native btSoftBody m_bUpdateRtCst(boolean setter); // Update runtime constants public native @ByRef btDbvt m_ndbvt(); public native btSoftBody m_ndbvt(btDbvt setter); // Nodes tree public native @ByRef btDbvt m_fdbvt(); public native btSoftBody m_fdbvt(btDbvt setter); // Faces tree - // Faces tree with normals + public native btDbvntNode m_fdbvnt(); public native btSoftBody m_fdbvnt(btDbvntNode setter); // Faces tree with normals public native @ByRef btDbvt m_cdbvt(); public native btSoftBody m_cdbvt(btDbvt setter); // Clusters tree public native @ByRef @Cast("btSoftBody::tClusterArray*") btSoftBodyClusterArray m_clusters(); public native btSoftBody m_clusters(btSoftBodyClusterArray setter); // Clusters public native @Cast("btScalar") float m_dampingCoefficient(); public native btSoftBody m_dampingCoefficient(float setter); // Damping Coefficient @@ -1441,7 +1606,7 @@ public native int rayFaceTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btV public static native void solveCommonConstraints(@Cast("btSoftBody**") PointerPointer bodies, int count, int iterations); public static native void solveCommonConstraints(@ByPtrPtr btSoftBody bodies, int count, int iterations); /* solveClusters */ - + public static native void solveClusters(@Const @ByRef btSoftBodyArray bodies); /* integrateMotion */ public native void integrateMotion(); /* defaultCollisionHandlers */ @@ -1527,7 +1692,7 @@ public native int rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVecto public native void updateClusters(); public native void cleanupClusters(); public native void prepareClusters(int iterations); - + public native void solveClusters(@Cast("btScalar") float sor); public native void applyClusters(@Cast("bool") boolean drift); public native void dampClusters(); public native void setSpringStiffness(@Cast("btScalar") float k); @@ -1545,11 +1710,10 @@ public native int rayTest(@Const @ByRef btVector3 rayFrom, @Const @ByRef btVecto public static native void PSolve_SContacts(btSoftBody psb, @Cast("btScalar") float arg1, @Cast("btScalar") float ti); public static native void PSolve_Links(btSoftBody psb, @Cast("btScalar") float kst, @Cast("btScalar") float ti); public static native void VSolve_Links(btSoftBody psb, @Cast("btScalar") float kst); - - + public static native psolver_t getSolver(@Cast("btSoftBody::ePSolver::_") int solver); public native void geometricCollisionHandler(btSoftBody psb); // #define SAFE_EPSILON SIMD_EPSILON * 100.0 - + public native void updateNode(btDbvtNode node, @Cast("bool") boolean use_velocity, @Cast("bool") boolean margin); public native void updateNodeTree(@Cast("bool") boolean use_velocity, @Cast("bool") boolean margin); public native void updateFaceTree(@Cast("bool") boolean use_velocity, @Cast("bool") boolean margin); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyArray.java index 82d8a57350c..c26c30d3a75 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyArray.java @@ -15,11 +15,7 @@ import static org.bytedeco.bullet.global.BulletDynamics.*; import static org.bytedeco.bullet.global.BulletSoftBody.*; - //for placement new -// #endif //BT_USE_PLACEMENT_NEW -/**The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) public class btSoftBodyArray extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyCollisionShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyCollisionShape.java new file mode 100644 index 00000000000..fdfc148f20a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyCollisionShape.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// btSoftBodyCollisionShape +// +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyCollisionShape extends btConcaveShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyCollisionShape(Pointer p) { super(p); } + + public native btSoftBody m_body(); public native btSoftBodyCollisionShape m_body(btSoftBody setter); + + public btSoftBodyCollisionShape(btSoftBody backptr) { super((Pointer)null); allocate(backptr); } + private native void allocate(btSoftBody backptr); + + public native void processAllTriangles(btTriangleCallback arg0, @Const @ByRef btVector3 arg1, @Const @ByRef btVector3 arg2); + + /**getAabb returns the axis aligned bounding box in the coordinate frame of the given transform t. */ + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native void setLocalScaling(@Const @ByRef btVector3 arg0); + public native @Const @ByRef btVector3 getLocalScaling(); + public native void calculateLocalInertia(@Cast("btScalar") float arg0, @ByRef btVector3 arg1); + public native @Cast("const char*") BytePointer getName(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.java new file mode 100644 index 00000000000..92c9f8ee5b4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.java @@ -0,0 +1,77 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/** btSoftBodyConcaveCollisionAlgorithm supports collision between soft body shapes and (concave) trianges meshes. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyConcaveCollisionAlgorithm extends btCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyConcaveCollisionAlgorithm(Pointer p) { super(p); } + + public btSoftBodyConcaveCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped) { super((Pointer)null); allocate(ci, body0Wrap, body1Wrap, isSwapped); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public native void clearCache(); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } + + public static class SwappedCreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public SwappedCreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public SwappedCreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public SwappedCreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public SwappedCreateFunc position(long position) { + return (SwappedCreateFunc)super.position(position); + } + @Override public SwappedCreateFunc getPointer(long i) { + return new SwappedCreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableFaceNodeContactArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableFaceNodeContactArray.java new file mode 100644 index 00000000000..329acaf2842 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableFaceNodeContactArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyDeformableFaceNodeContactArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyDeformableFaceNodeContactArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyDeformableFaceNodeContactArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSoftBodyDeformableFaceNodeContactArray position(long position) { + return (btSoftBodyDeformableFaceNodeContactArray)super.position(position); + } + @Override public btSoftBodyDeformableFaceNodeContactArray getPointer(long i) { + return new btSoftBodyDeformableFaceNodeContactArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSoftBodyDeformableFaceNodeContactArray put(@Const @ByRef btSoftBodyDeformableFaceNodeContactArray other); + public btSoftBodyDeformableFaceNodeContactArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSoftBodyDeformableFaceNodeContactArray(@Const @ByRef btSoftBodyDeformableFaceNodeContactArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyDeformableFaceNodeContactArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.DeformableFaceNodeContact at(int n); + + public native @ByRef @Name("operator []") btSoftBody.DeformableFaceNodeContact get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::DeformableFaceNodeContact()") btSoftBody.DeformableFaceNodeContact fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.DeformableFaceNodeContact expandNonInitializing(); + + public native @ByRef btSoftBody.DeformableFaceNodeContact expand(@Const @ByRef(nullValue = "btSoftBody::DeformableFaceNodeContact()") btSoftBody.DeformableFaceNodeContact fillValue); + public native @ByRef btSoftBody.DeformableFaceNodeContact expand(); + + public native void push_back(@Const @ByRef btSoftBody.DeformableFaceNodeContact _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSoftBodyDeformableFaceNodeContactArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableFaceRigidContactArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableFaceRigidContactArray.java new file mode 100644 index 00000000000..1febfd6417b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableFaceRigidContactArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyDeformableFaceRigidContactArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyDeformableFaceRigidContactArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyDeformableFaceRigidContactArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSoftBodyDeformableFaceRigidContactArray position(long position) { + return (btSoftBodyDeformableFaceRigidContactArray)super.position(position); + } + @Override public btSoftBodyDeformableFaceRigidContactArray getPointer(long i) { + return new btSoftBodyDeformableFaceRigidContactArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSoftBodyDeformableFaceRigidContactArray put(@Const @ByRef btSoftBodyDeformableFaceRigidContactArray other); + public btSoftBodyDeformableFaceRigidContactArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSoftBodyDeformableFaceRigidContactArray(@Const @ByRef btSoftBodyDeformableFaceRigidContactArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyDeformableFaceRigidContactArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.DeformableFaceRigidContact at(int n); + + public native @ByRef @Name("operator []") btSoftBody.DeformableFaceRigidContact get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::DeformableFaceRigidContact()") btSoftBody.DeformableFaceRigidContact fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.DeformableFaceRigidContact expandNonInitializing(); + + public native @ByRef btSoftBody.DeformableFaceRigidContact expand(@Const @ByRef(nullValue = "btSoftBody::DeformableFaceRigidContact()") btSoftBody.DeformableFaceRigidContact fillValue); + public native @ByRef btSoftBody.DeformableFaceRigidContact expand(); + + public native void push_back(@Const @ByRef btSoftBody.DeformableFaceRigidContact _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSoftBodyDeformableFaceRigidContactArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableNodeRigidAnchorArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableNodeRigidAnchorArray.java new file mode 100644 index 00000000000..89df9d507c3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableNodeRigidAnchorArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyDeformableNodeRigidAnchorArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyDeformableNodeRigidAnchorArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyDeformableNodeRigidAnchorArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSoftBodyDeformableNodeRigidAnchorArray position(long position) { + return (btSoftBodyDeformableNodeRigidAnchorArray)super.position(position); + } + @Override public btSoftBodyDeformableNodeRigidAnchorArray getPointer(long i) { + return new btSoftBodyDeformableNodeRigidAnchorArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSoftBodyDeformableNodeRigidAnchorArray put(@Const @ByRef btSoftBodyDeformableNodeRigidAnchorArray other); + public btSoftBodyDeformableNodeRigidAnchorArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSoftBodyDeformableNodeRigidAnchorArray(@Const @ByRef btSoftBodyDeformableNodeRigidAnchorArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyDeformableNodeRigidAnchorArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.DeformableNodeRigidAnchor at(int n); + + public native @ByRef @Name("operator []") btSoftBody.DeformableNodeRigidAnchor get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::DeformableNodeRigidAnchor()") btSoftBody.DeformableNodeRigidAnchor fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.DeformableNodeRigidAnchor expandNonInitializing(); + + public native @ByRef btSoftBody.DeformableNodeRigidAnchor expand(@Const @ByRef(nullValue = "btSoftBody::DeformableNodeRigidAnchor()") btSoftBody.DeformableNodeRigidAnchor fillValue); + public native @ByRef btSoftBody.DeformableNodeRigidAnchor expand(); + + public native void push_back(@Const @ByRef btSoftBody.DeformableNodeRigidAnchor _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSoftBodyDeformableNodeRigidAnchorArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableNodeRigidContactArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableNodeRigidContactArray.java new file mode 100644 index 00000000000..03a4cb71d72 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyDeformableNodeRigidContactArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyDeformableNodeRigidContactArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyDeformableNodeRigidContactArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyDeformableNodeRigidContactArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSoftBodyDeformableNodeRigidContactArray position(long position) { + return (btSoftBodyDeformableNodeRigidContactArray)super.position(position); + } + @Override public btSoftBodyDeformableNodeRigidContactArray getPointer(long i) { + return new btSoftBodyDeformableNodeRigidContactArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSoftBodyDeformableNodeRigidContactArray put(@Const @ByRef btSoftBodyDeformableNodeRigidContactArray other); + public btSoftBodyDeformableNodeRigidContactArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSoftBodyDeformableNodeRigidContactArray(@Const @ByRef btSoftBodyDeformableNodeRigidContactArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyDeformableNodeRigidContactArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.DeformableNodeRigidContact at(int n); + + public native @ByRef @Name("operator []") btSoftBody.DeformableNodeRigidContact get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::DeformableNodeRigidContact()") btSoftBody.DeformableNodeRigidContact fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.DeformableNodeRigidContact expandNonInitializing(); + + public native @ByRef btSoftBody.DeformableNodeRigidContact expand(@Const @ByRef(nullValue = "btSoftBody::DeformableNodeRigidContact()") btSoftBody.DeformableNodeRigidContact fillValue); + public native @ByRef btSoftBody.DeformableNodeRigidContact expand(); + + public native void push_back(@Const @ByRef btSoftBody.DeformableNodeRigidContact _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSoftBodyDeformableNodeRigidContactArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyFloatData.java new file mode 100644 index 00000000000..869012a7ab7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyFloatData.java @@ -0,0 +1,61 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSoftBodyFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSoftBodyFloatData position(long position) { + return (btSoftBodyFloatData)super.position(position); + } + @Override public btSoftBodyFloatData getPointer(long i) { + return new btSoftBodyFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef btCollisionObjectFloatData m_collisionObjectData(); public native btSoftBodyFloatData m_collisionObjectData(btCollisionObjectFloatData setter); + + public native SoftBodyPoseData m_pose(); public native btSoftBodyFloatData m_pose(SoftBodyPoseData setter); + public native SoftBodyMaterialData m_materials(int i); public native btSoftBodyFloatData m_materials(int i, SoftBodyMaterialData setter); + public native @Cast("SoftBodyMaterialData**") PointerPointer m_materials(); public native btSoftBodyFloatData m_materials(PointerPointer setter); + public native SoftBodyNodeData m_nodes(); public native btSoftBodyFloatData m_nodes(SoftBodyNodeData setter); + public native SoftBodyLinkData m_links(); public native btSoftBodyFloatData m_links(SoftBodyLinkData setter); + public native SoftBodyFaceData m_faces(); public native btSoftBodyFloatData m_faces(SoftBodyFaceData setter); + public native SoftBodyTetraData m_tetrahedra(); public native btSoftBodyFloatData m_tetrahedra(SoftBodyTetraData setter); + public native SoftRigidAnchorData m_anchors(); public native btSoftBodyFloatData m_anchors(SoftRigidAnchorData setter); + public native SoftBodyClusterData m_clusters(); public native btSoftBodyFloatData m_clusters(SoftBodyClusterData setter); + public native btSoftBodyJointData m_joints(); public native btSoftBodyFloatData m_joints(btSoftBodyJointData setter); + + public native int m_numMaterials(); public native btSoftBodyFloatData m_numMaterials(int setter); + public native int m_numNodes(); public native btSoftBodyFloatData m_numNodes(int setter); + public native int m_numLinks(); public native btSoftBodyFloatData m_numLinks(int setter); + public native int m_numFaces(); public native btSoftBodyFloatData m_numFaces(int setter); + public native int m_numTetrahedra(); public native btSoftBodyFloatData m_numTetrahedra(int setter); + public native int m_numAnchors(); public native btSoftBodyFloatData m_numAnchors(int setter); + public native int m_numClusters(); public native btSoftBodyFloatData m_numClusters(int setter); + public native int m_numJoints(); public native btSoftBodyFloatData m_numJoints(int setter); + public native @ByRef SoftBodyConfigData m_config(); public native btSoftBodyFloatData m_config(SoftBodyConfigData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyJointData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyJointData.java new file mode 100644 index 00000000000..93a3d595253 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyJointData.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyJointData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSoftBodyJointData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyJointData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyJointData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSoftBodyJointData position(long position) { + return (btSoftBodyJointData)super.position(position); + } + @Override public btSoftBodyJointData getPointer(long i) { + return new btSoftBodyJointData((Pointer)this).offsetAddress(i); + } + + public native Pointer m_bodyA(); public native btSoftBodyJointData m_bodyA(Pointer setter); + public native Pointer m_bodyB(); public native btSoftBodyJointData m_bodyB(Pointer setter); + public native @ByRef btVector3FloatData m_refs(int i); public native btSoftBodyJointData m_refs(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_refs(); + public native float m_cfm(); public native btSoftBodyJointData m_cfm(float setter); + public native float m_erp(); public native btSoftBodyJointData m_erp(float setter); + public native float m_split(); public native btSoftBodyJointData m_split(float setter); + public native int m_delete(); public native btSoftBodyJointData m_delete(int setter); + public native @ByRef btVector3FloatData m_relPosition(int i); public native btSoftBodyJointData m_relPosition(int i, btVector3FloatData setter); + @MemberGetter public native btVector3FloatData m_relPosition(); //linear + public native int m_bodyAtype(); public native btSoftBodyJointData m_bodyAtype(int setter); + public native int m_bodyBtype(); public native btSoftBodyJointData m_bodyBtype(int setter); + public native int m_jointType(); public native btSoftBodyJointData m_jointType(int setter); + public native int m_pad(); public native btSoftBodyJointData m_pad(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java new file mode 100644 index 00000000000..99dc91faf1a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyLinkData.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyLinkData extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSoftBodyLinkData() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyLinkData(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNodePointerArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNodePointerArray.java new file mode 100644 index 00000000000..93484682ee4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyNodePointerArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyNodePointerArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyNodePointerArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyNodePointerArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSoftBodyNodePointerArray position(long position) { + return (btSoftBodyNodePointerArray)super.position(position); + } + @Override public btSoftBodyNodePointerArray getPointer(long i) { + return new btSoftBodyNodePointerArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSoftBodyNodePointerArray put(@Const @ByRef btSoftBodyNodePointerArray other); + public btSoftBodyNodePointerArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSoftBodyNodePointerArray(@Const @ByRef btSoftBodyNodePointerArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyNodePointerArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btSoftBody.Node at(int n); + + public native @ByPtrRef @Name("operator []") btSoftBody.Node get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btSoftBody.Node fillData/*=btSoftBody::Node*()*/); + public native void resize(int newsize); + public native @ByPtrRef btSoftBody.Node expandNonInitializing(); + + public native @ByPtrRef btSoftBody.Node expand(@ByPtrRef btSoftBody.Node fillValue/*=btSoftBody::Node*()*/); + public native @ByPtrRef btSoftBody.Node expand(); + + public native void push_back(@ByPtrRef btSoftBody.Node _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btSoftBody.Node key); + + public native int findLinearSearch(@ByPtrRef btSoftBody.Node key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btSoftBody.Node key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btSoftBody.Node key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSoftBodyNodePointerArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTetraSratchArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTetraSratchArray.java new file mode 100644 index 00000000000..0370f4e4ec3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTetraSratchArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyTetraSratchArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyTetraSratchArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftBodyTetraSratchArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSoftBodyTetraSratchArray position(long position) { + return (btSoftBodyTetraSratchArray)super.position(position); + } + @Override public btSoftBodyTetraSratchArray getPointer(long i) { + return new btSoftBodyTetraSratchArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSoftBodyTetraSratchArray put(@Const @ByRef btSoftBodyTetraSratchArray other); + public btSoftBodyTetraSratchArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSoftBodyTetraSratchArray(@Const @ByRef btSoftBodyTetraSratchArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSoftBodyTetraSratchArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef btSoftBody.TetraScratch at(int n); + + public native @ByRef @Name("operator []") btSoftBody.TetraScratch get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "btSoftBody::TetraScratch()") btSoftBody.TetraScratch fillData); + public native void resize(int newsize); + public native @ByRef btSoftBody.TetraScratch expandNonInitializing(); + + public native @ByRef btSoftBody.TetraScratch expand(@Const @ByRef(nullValue = "btSoftBody::TetraScratch()") btSoftBody.TetraScratch fillValue); + public native @ByRef btSoftBody.TetraScratch expand(); + + public native void push_back(@Const @ByRef btSoftBody.TetraScratch _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + + + public native void removeAtIndex(int index); + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSoftBodyTetraSratchArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleCallback.java new file mode 100644 index 00000000000..9d5d68fa7ed --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleCallback.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/**For each triangle in the concave mesh that overlaps with the AABB of a soft body (m_softBody), processTriangle is called. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyTriangleCallback extends btTriangleCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyTriangleCallback(Pointer p) { super(p); } + + public native int m_triangleCount(); public native btSoftBodyTriangleCallback m_triangleCount(int setter); + + // btPersistentManifold* m_manifoldPtr; + + public btSoftBodyTriangleCallback(btDispatcher dispatcher, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped) { super((Pointer)null); allocate(dispatcher, body0Wrap, body1Wrap, isSwapped); } + private native void allocate(btDispatcher dispatcher, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Cast("bool") boolean isSwapped); + + public native void setTimeStepAndCounters(@Cast("btScalar") float collisionMarginTriangle, @Const btCollisionObjectWrapper triObjWrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void processTriangle(btVector3 triangle, int partId, int triangleIndex); + + public native void clearCache(); + + public native @Const @ByRef btVector3 getAabbMin(); + public native @Const @ByRef btVector3 getAabbMax(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java new file mode 100644 index 00000000000..4d151a85e26 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyTriangleData.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyTriangleData extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSoftBodyTriangleData() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyTriangleData(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java new file mode 100644 index 00000000000..3ca8a62e58d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyVertexData.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftBodyVertexData extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public btSoftBodyVertexData() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftBodyVertexData(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java index 88220cf2bbd..a7775d28dd8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftBodyWorldInfo.java @@ -41,7 +41,7 @@ public class btSoftBodyWorldInfo extends Pointer { public native btBroadphaseInterface m_broadphase(); public native btSoftBodyWorldInfo m_broadphase(btBroadphaseInterface setter); public native btDispatcher m_dispatcher(); public native btSoftBodyWorldInfo m_dispatcher(btDispatcher setter); public native @ByRef btVector3 m_gravity(); public native btSoftBodyWorldInfo m_gravity(btVector3 setter); - public native @ByRef btSparseSdf_3 m_sparsesdf(); public native btSoftBodyWorldInfo m_sparsesdf(btSparseSdf_3 setter); + public native @ByRef btSparseSdf3 m_sparsesdf(); public native btSoftBodyWorldInfo m_sparsesdf(btSparseSdf3 setter); public btSoftBodyWorldInfo() { super((Pointer)null); allocate(); } private native void allocate(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftClusterCollisionShape.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftClusterCollisionShape.java new file mode 100644 index 00000000000..856a3732e67 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftClusterCollisionShape.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// btSoftClusterCollisionShape +// +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftClusterCollisionShape extends btConvexInternalShape { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftClusterCollisionShape(Pointer p) { super(p); } + + public native @Const btSoftBody.Cluster m_cluster(); public native btSoftClusterCollisionShape m_cluster(btSoftBody.Cluster setter); + + public btSoftClusterCollisionShape(@Const btSoftBody.Cluster cluster) { super((Pointer)null); allocate(cluster); } + private native void allocate(@Const btSoftBody.Cluster cluster); + + public native @ByVal btVector3 localGetSupportingVertex(@Const @ByRef btVector3 vec); + public native @ByVal btVector3 localGetSupportingVertexWithoutMargin(@Const @ByRef btVector3 vec); + //notice that the vectors should be unit length + public native void batchedUnitVectorGetSupportingVertexWithoutMargin(@Const btVector3 vectors, btVector3 supportVerticesOut, int numVectors); + + public native void calculateLocalInertia(@Cast("btScalar") float mass, @ByRef btVector3 inertia); + + public native void getAabb(@Const @ByRef btTransform t, @ByRef btVector3 aabbMin, @ByRef btVector3 aabbMax); + + public native int getShapeType(); + + //debugging + public native @Cast("const char*") BytePointer getName(); + + public native void setMargin(@Cast("btScalar") float margin); + public native @Cast("btScalar") float getMargin(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftColliders.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftColliders.java new file mode 100644 index 00000000000..dbe6239b3c7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftColliders.java @@ -0,0 +1,319 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +// +// btSoftColliders +// +@Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftColliders extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSoftColliders() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSoftColliders(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftColliders(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSoftColliders position(long position) { + return (btSoftColliders)super.position(position); + } + @Override public btSoftColliders getPointer(long i) { + return new btSoftColliders((Pointer)this).offsetAddress(i); + } + + // + // ClusterBase + // + @NoOffset public static class ClusterBase extends btDbvt.ICollide { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ClusterBase(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public ClusterBase(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public ClusterBase position(long position) { + return (ClusterBase)super.position(position); + } + @Override public ClusterBase getPointer(long i) { + return new ClusterBase((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float erp(); public native ClusterBase erp(float setter); + public native @Cast("btScalar") float idt(); public native ClusterBase idt(float setter); + public native @Cast("btScalar") float m_margin(); public native ClusterBase m_margin(float setter); + public native @Cast("btScalar") float friction(); public native ClusterBase friction(float setter); + public native @Cast("btScalar") float threshold(); public native ClusterBase threshold(float setter); + public ClusterBase() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("bool") boolean SolveContact(@Const @ByRef btGjkEpaSolver2.sResults res, + @ByVal btSoftBody.Body ba, @Const @ByVal btSoftBody.Body bb, + @ByRef btSoftBody.CJoint joint); + } + // + // CollideCL_RS + // + @NoOffset public static class CollideCL_RS extends ClusterBase { + static { Loader.load(); } + /** Default native constructor. */ + public CollideCL_RS() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideCL_RS(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideCL_RS(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideCL_RS position(long position) { + return (CollideCL_RS)super.position(position); + } + @Override public CollideCL_RS getPointer(long i) { + return new CollideCL_RS((Pointer)this).offsetAddress(i); + } + + public native btSoftBody psb(); public native CollideCL_RS psb(btSoftBody setter); + public native @Const btCollisionObjectWrapper m_colObjWrap(); public native CollideCL_RS m_colObjWrap(btCollisionObjectWrapper setter); + + public native void Process(@Const btDbvtNode leaf); + public native void ProcessColObj(btSoftBody ps, @Const btCollisionObjectWrapper colObWrap); + } + // + // CollideCL_SS + // + @NoOffset public static class CollideCL_SS extends ClusterBase { + static { Loader.load(); } + /** Default native constructor. */ + public CollideCL_SS() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideCL_SS(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideCL_SS(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideCL_SS position(long position) { + return (CollideCL_SS)super.position(position); + } + @Override public CollideCL_SS getPointer(long i) { + return new CollideCL_SS((Pointer)this).offsetAddress(i); + } + + public native btSoftBody bodies(int i); public native CollideCL_SS bodies(int i, btSoftBody setter); + @MemberGetter public native @Cast("btSoftBody**") PointerPointer bodies(); + public native void Process(@Const btDbvtNode la, @Const btDbvtNode lb); + public native void ProcessSoftSoft(btSoftBody psa, btSoftBody psb); + } + // + // CollideSDF_RS + // + @NoOffset public static class CollideSDF_RS extends btDbvt.ICollide { + static { Loader.load(); } + /** Default native constructor. */ + public CollideSDF_RS() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideSDF_RS(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideSDF_RS(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideSDF_RS position(long position) { + return (CollideSDF_RS)super.position(position); + } + @Override public CollideSDF_RS getPointer(long i) { + return new CollideSDF_RS((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const btDbvtNode leaf); + public native void DoNode(@ByRef btSoftBody.Node n); + public native btSoftBody psb(); public native CollideSDF_RS psb(btSoftBody setter); + public native @Const btCollisionObjectWrapper m_colObj1Wrap(); public native CollideSDF_RS m_colObj1Wrap(btCollisionObjectWrapper setter); + public native btRigidBody m_rigidBody(); public native CollideSDF_RS m_rigidBody(btRigidBody setter); + public native @Cast("btScalar") float dynmargin(); public native CollideSDF_RS dynmargin(float setter); + public native @Cast("btScalar") float stamargin(); public native CollideSDF_RS stamargin(float setter); + } + + // + // CollideSDF_RD + // + @NoOffset public static class CollideSDF_RD extends btDbvt.ICollide { + static { Loader.load(); } + /** Default native constructor. */ + public CollideSDF_RD() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideSDF_RD(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideSDF_RD(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideSDF_RD position(long position) { + return (CollideSDF_RD)super.position(position); + } + @Override public CollideSDF_RD getPointer(long i) { + return new CollideSDF_RD((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const btDbvtNode leaf); + public native void DoNode(@ByRef btSoftBody.Node n); + public native btSoftBody psb(); public native CollideSDF_RD psb(btSoftBody setter); + public native @Const btCollisionObjectWrapper m_colObj1Wrap(); public native CollideSDF_RD m_colObj1Wrap(btCollisionObjectWrapper setter); + public native btRigidBody m_rigidBody(); public native CollideSDF_RD m_rigidBody(btRigidBody setter); + public native @Cast("btScalar") float dynmargin(); public native CollideSDF_RD dynmargin(float setter); + public native @Cast("btScalar") float stamargin(); public native CollideSDF_RD stamargin(float setter); + } + + // + // CollideSDF_RDF + // + @NoOffset public static class CollideSDF_RDF extends btDbvt.ICollide { + static { Loader.load(); } + /** Default native constructor. */ + public CollideSDF_RDF() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideSDF_RDF(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideSDF_RDF(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideSDF_RDF position(long position) { + return (CollideSDF_RDF)super.position(position); + } + @Override public CollideSDF_RDF getPointer(long i) { + return new CollideSDF_RDF((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const btDbvtNode leaf); + public native void DoNode(@ByRef btSoftBody.Face f); + public native btSoftBody psb(); public native CollideSDF_RDF psb(btSoftBody setter); + public native @Const btCollisionObjectWrapper m_colObj1Wrap(); public native CollideSDF_RDF m_colObj1Wrap(btCollisionObjectWrapper setter); + public native btRigidBody m_rigidBody(); public native CollideSDF_RDF m_rigidBody(btRigidBody setter); + public native @Cast("btScalar") float dynmargin(); public native CollideSDF_RDF dynmargin(float setter); + public native @Cast("btScalar") float stamargin(); public native CollideSDF_RDF stamargin(float setter); + } + + // + // CollideVF_SS + // + @NoOffset public static class CollideVF_SS extends btDbvt.ICollide { + static { Loader.load(); } + /** Default native constructor. */ + public CollideVF_SS() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideVF_SS(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideVF_SS(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideVF_SS position(long position) { + return (CollideVF_SS)super.position(position); + } + @Override public CollideVF_SS getPointer(long i) { + return new CollideVF_SS((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const btDbvtNode lnode, + @Const btDbvtNode lface); + public native btSoftBody psb(int i); public native CollideVF_SS psb(int i, btSoftBody setter); + @MemberGetter public native @Cast("btSoftBody**") PointerPointer psb(); + public native @Cast("btScalar") float mrg(); public native CollideVF_SS mrg(float setter); + } + + // + // CollideVF_DD + // + @NoOffset public static class CollideVF_DD extends btDbvt.ICollide { + static { Loader.load(); } + /** Default native constructor. */ + public CollideVF_DD() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideVF_DD(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideVF_DD(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideVF_DD position(long position) { + return (CollideVF_DD)super.position(position); + } + @Override public CollideVF_DD getPointer(long i) { + return new CollideVF_DD((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const btDbvtNode lnode, + @Const btDbvtNode lface); + public native btSoftBody psb(int i); public native CollideVF_DD psb(int i, btSoftBody setter); + @MemberGetter public native @Cast("btSoftBody**") PointerPointer psb(); + public native @Cast("btScalar") float mrg(); public native CollideVF_DD mrg(float setter); + public native @Cast("bool") boolean useFaceNormal(); public native CollideVF_DD useFaceNormal(boolean setter); + } + + // + // CollideFF_DD + // + @NoOffset public static class CollideFF_DD extends btDbvt.ICollide { + static { Loader.load(); } + /** Default native constructor. */ + public CollideFF_DD() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideFF_DD(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideFF_DD(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideFF_DD position(long position) { + return (CollideFF_DD)super.position(position); + } + @Override public CollideFF_DD getPointer(long i) { + return new CollideFF_DD((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const btDbvntNode lface1, + @Const btDbvntNode lface2); + public native void Repel(btSoftBody.Face f1, btSoftBody.Face f2); + public native btSoftBody psb(int i); public native CollideFF_DD psb(int i, btSoftBody setter); + @MemberGetter public native @Cast("btSoftBody**") PointerPointer psb(); + public native @Cast("btScalar") float mrg(); public native CollideFF_DD mrg(float setter); + public native @Cast("bool") boolean useFaceNormal(); public native CollideFF_DD useFaceNormal(boolean setter); + } + + @NoOffset public static class CollideCCD extends btDbvt.ICollide { + static { Loader.load(); } + /** Default native constructor. */ + public CollideCCD() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CollideCCD(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CollideCCD(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CollideCCD position(long position) { + return (CollideCCD)super.position(position); + } + @Override public CollideCCD getPointer(long i) { + return new CollideCCD((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const btDbvtNode lnode, + @Const btDbvtNode lface); + public native void Process(@Const btDbvntNode lface1, + @Const btDbvntNode lface2); + public native void Repel(btSoftBody.Face f1, btSoftBody.Face f2); + public native btSoftBody psb(int i); public native CollideCCD psb(int i, btSoftBody setter); + @MemberGetter public native @Cast("btSoftBody**") PointerPointer psb(); + public native @Cast("btScalar") float dt(); public native CollideCCD dt(float setter); + public native @Cast("btScalar") float mrg(); public native CollideCCD mrg(float setter); + public native @Cast("bool") boolean useFaceNormal(); public native CollideCCD useFaceNormal(boolean setter); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidCollisionAlgorithm.java new file mode 100644 index 00000000000..dbed965546c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftRigidCollisionAlgorithm.java @@ -0,0 +1,55 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/** btSoftRigidCollisionAlgorithm provides collision detection between btSoftBody and btRigidBody */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftRigidCollisionAlgorithm extends btCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftRigidCollisionAlgorithm(Pointer p) { super(p); } + + public btSoftRigidCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0, @Const btCollisionObjectWrapper col1Wrap, @Cast("bool") boolean isSwapped) { super((Pointer)null); allocate(mf, ci, col0, col1Wrap, isSwapped); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper col0, @Const btCollisionObjectWrapper col1Wrap, @Cast("bool") boolean isSwapped); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftSoftCollisionAlgorithm.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftSoftCollisionAlgorithm.java new file mode 100644 index 00000000000..ff207e0be0e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSoftSoftCollisionAlgorithm.java @@ -0,0 +1,58 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +/**collision detection between two btSoftBody shapes */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSoftSoftCollisionAlgorithm extends btCollisionAlgorithm { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSoftSoftCollisionAlgorithm(Pointer p) { super(p); } + + public btSoftSoftCollisionAlgorithm(@Const @ByRef btCollisionAlgorithmConstructionInfo ci) { super((Pointer)null); allocate(ci); } + private native void allocate(@Const @ByRef btCollisionAlgorithmConstructionInfo ci); + + public native void processCollision(@Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native @Cast("btScalar") float calculateTimeOfImpact(btCollisionObject body0, btCollisionObject body1, @Const @ByRef btDispatcherInfo dispatchInfo, btManifoldResult resultOut); + + public native void getAllContactManifolds(@Cast("btManifoldArray*") @ByRef btPersistentManifoldArray manifoldArray); + + public btSoftSoftCollisionAlgorithm(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap) { super((Pointer)null); allocate(mf, ci, body0Wrap, body1Wrap); } + private native void allocate(btPersistentManifold mf, @Const @ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + + public static class CreateFunc extends btCollisionAlgorithmCreateFunc { + static { Loader.load(); } + /** Default native constructor. */ + public CreateFunc() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public CreateFunc(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateFunc(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public CreateFunc position(long position) { + return (CreateFunc)super.position(position); + } + @Override public CreateFunc getPointer(long i) { + return new CreateFunc((Pointer)this).offsetAddress(i); + } + + public native btCollisionAlgorithm CreateCollisionAlgorithm(@ByRef btCollisionAlgorithmConstructionInfo ci, @Const btCollisionObjectWrapper body0Wrap, @Const btCollisionObjectWrapper body1Wrap); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf3.java new file mode 100644 index 00000000000..63ecc445a08 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf3.java @@ -0,0 +1,134 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + + +@Name("btSparseSdf<3>") @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSparseSdf3 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btSparseSdf3() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSparseSdf3(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSparseSdf3(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btSparseSdf3 position(long position) { + return (btSparseSdf3)super.position(position); + } + @Override public btSparseSdf3 getPointer(long i) { + return new btSparseSdf3((Pointer)this).offsetAddress(i); + } + + // + // Inner types + // + public static class IntFrac extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public IntFrac() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public IntFrac(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IntFrac(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public IntFrac position(long position) { + return (IntFrac)super.position(position); + } + @Override public IntFrac getPointer(long i) { + return new IntFrac((Pointer)this).offsetAddress(i); + } + + public native int b(); public native IntFrac b(int setter); + public native int i(); public native IntFrac i(int setter); + public native @Cast("btScalar") float f(); public native IntFrac f(float setter); + } + public static class Cell extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public Cell() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Cell(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Cell(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Cell position(long position) { + return (Cell)super.position(position); + } + @Override public Cell getPointer(long i) { + return new Cell((Pointer)this).offsetAddress(i); + } + + public native @Cast("btScalar") float d(int i, int j, int k); public native Cell d(int i, int j, int k, float setter); + @MemberGetter public native @Cast("btScalar*") FloatPointer d(); + public native int c(int i); public native Cell c(int i, int setter); + @MemberGetter public native IntPointer c(); + public native int puid(); public native Cell puid(int setter); + public native @Cast("unsigned") int hash(); public native Cell hash(int setter); + public native @Const btCollisionShape pclient(); public native Cell pclient(btCollisionShape setter); + public native Cell next(); public native Cell next(Cell setter); + } + // + // Fields + // + + public native @ByRef btSparseSdf3CellArray cells(); public native btSparseSdf3 cells(btSparseSdf3CellArray setter); + public native @Cast("btScalar") float voxelsz(); public native btSparseSdf3 voxelsz(float setter); + public native @Cast("btScalar") float m_defaultVoxelsz(); public native btSparseSdf3 m_defaultVoxelsz(float setter); + public native int puid(); public native btSparseSdf3 puid(int setter); + public native int ncells(); public native btSparseSdf3 ncells(int setter); + public native int m_clampCells(); public native btSparseSdf3 m_clampCells(int setter); + public native int nprobes(); public native btSparseSdf3 nprobes(int setter); + public native int nqueries(); public native btSparseSdf3 nqueries(int setter); + // + // Methods + // + + // + public native void Initialize(int hashsize/*=2383*/, int clampCells/*=256 * 1024*/); + public native void Initialize(); + // + + public native void setDefaultVoxelsz(@Cast("btScalar") float sz); + + public native void Reset(); + // + public native void GarbageCollect(int lifetime/*=256*/); + public native void GarbageCollect(); + // + public native int RemoveReferences(btCollisionShape pcs); + // + public native @Cast("btScalar") float Evaluate(@Const @ByRef btVector3 x, + @Const btCollisionShape shape, + @ByRef btVector3 normal, + @Cast("btScalar") float margin); + // + public native void BuildCell(@ByRef Cell c); + // + public static native @Cast("btScalar") float DistanceToShape(@Const @ByRef btVector3 x, + @Const btCollisionShape shape); + // + public static native @ByVal IntFrac Decompose(@Cast("btScalar") float x); + // + public static native @Cast("btScalar") float Lerp(@Cast("btScalar") float a, @Cast("btScalar") float b, @Cast("btScalar") float t); + + // + public static native @Cast("unsigned int") int Hash(int x, int y, int z, @Const btCollisionShape shape); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf3CellArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf3CellArray.java new file mode 100644 index 00000000000..e37548b41cd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf3CellArray.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + +@Name("btAlignedObjectArray::Cell*>") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btSparseSdf3CellArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btSparseSdf3CellArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btSparseSdf3CellArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public btSparseSdf3CellArray position(long position) { + return (btSparseSdf3CellArray)super.position(position); + } + @Override public btSparseSdf3CellArray getPointer(long i) { + return new btSparseSdf3CellArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") btSparseSdf3CellArray put(@Const @ByRef btSparseSdf3CellArray other); + public btSparseSdf3CellArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ + public btSparseSdf3CellArray(@Const @ByRef btSparseSdf3CellArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef btSparseSdf3CellArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef btSparseSdf3.Cell at(int n); + + public native @ByPtrRef @Name("operator []") btSparseSdf3.Cell get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef btSparseSdf3.Cell fillData/*=btSparseSdf<3>::Cell*()*/); + public native void resize(int newsize); + public native @ByPtrRef btSparseSdf3.Cell expandNonInitializing(); + + public native @ByPtrRef btSparseSdf3.Cell expand(@ByPtrRef btSparseSdf3.Cell fillValue/*=btSparseSdf<3>::Cell*()*/); + public native @ByPtrRef btSparseSdf3.Cell expand(); + + public native void push_back(@ByPtrRef btSparseSdf3.Cell _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef btSparseSdf3.Cell key); + + public native int findLinearSearch(@ByPtrRef btSparseSdf3.Cell key); + + // If the key is not in the array, return -1 instead of 0, + // since 0 also means the first element in the array. + public native int findLinearSearch2(@ByPtrRef btSparseSdf3.Cell key); + + public native void removeAtIndex(int index); + public native void remove(@ByPtrRef btSparseSdf3.Cell key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef btSparseSdf3CellArray otherArray); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java deleted file mode 100644 index f849c4b1b1f..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btSparseSdf_3.java +++ /dev/null @@ -1,85 +0,0 @@ -// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.BulletSoftBody; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.LinearMath.*; -import static org.bytedeco.bullet.global.LinearMath.*; -import org.bytedeco.bullet.BulletCollision.*; -import static org.bytedeco.bullet.global.BulletCollision.*; -import org.bytedeco.bullet.BulletDynamics.*; -import static org.bytedeco.bullet.global.BulletDynamics.*; - -import static org.bytedeco.bullet.global.BulletSoftBody.*; - - -@Name("btSparseSdf<3>") @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) -public class btSparseSdf_3 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public btSparseSdf_3() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public btSparseSdf_3(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public btSparseSdf_3(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public btSparseSdf_3 position(long position) { - return (btSparseSdf_3)super.position(position); - } - @Override public btSparseSdf_3 getPointer(long i) { - return new btSparseSdf_3((Pointer)this).offsetAddress(i); - } - - // - // Inner types - // - // - // Fields - // - - - public native @Cast("btScalar") float voxelsz(); public native btSparseSdf_3 voxelsz(float setter); - public native @Cast("btScalar") float m_defaultVoxelsz(); public native btSparseSdf_3 m_defaultVoxelsz(float setter); - public native int puid(); public native btSparseSdf_3 puid(int setter); - public native int ncells(); public native btSparseSdf_3 ncells(int setter); - public native int m_clampCells(); public native btSparseSdf_3 m_clampCells(int setter); - public native int nprobes(); public native btSparseSdf_3 nprobes(int setter); - public native int nqueries(); public native btSparseSdf_3 nqueries(int setter); - // - // Methods - // - - // - public native void Initialize(int hashsize/*=2383*/, int clampCells/*=256 * 1024*/); - public native void Initialize(); - // - - public native void setDefaultVoxelsz(@Cast("btScalar") float sz); - - public native void Reset(); - // - public native void GarbageCollect(int lifetime/*=256*/); - public native void GarbageCollect(); - // - public native int RemoveReferences(btCollisionShape pcs); - // - public native @Cast("btScalar") float Evaluate(@Const @ByRef btVector3 x, - @Const btCollisionShape shape, - @ByRef btVector3 normal, - @Cast("btScalar") float margin); - // - // - public static native @Cast("btScalar") float DistanceToShape(@Const @ByRef btVector3 x, - @Const btCollisionShape shape); - // - // - public static native @Cast("btScalar") float Lerp(@Cast("btScalar") float a, @Cast("btScalar") float b, @Cast("btScalar") float t); - - // - public static native @Cast("unsigned int") int Hash(int x, int y, int z, @Const btCollisionShape shape); -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btTriIndex.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btTriIndex.java new file mode 100644 index 00000000000..fa3895d2db3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btTriIndex.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.BulletSoftBody; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; +import org.bytedeco.bullet.BulletCollision.*; +import static org.bytedeco.bullet.global.BulletCollision.*; +import org.bytedeco.bullet.BulletDynamics.*; +import static org.bytedeco.bullet.global.BulletDynamics.*; + +import static org.bytedeco.bullet.global.BulletSoftBody.*; + //for definition of MAX_NUM_PARTS_IN_BITS + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletSoftBody.class) +public class btTriIndex extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btTriIndex(Pointer p) { super(p); } + + public native int m_PartIdTriangleIndex(); public native btTriIndex m_PartIdTriangleIndex(int setter); + public native btCollisionShape m_childShape(); public native btTriIndex m_childShape(btCollisionShape setter); + + public btTriIndex(int partId, int triangleIndex, btCollisionShape shape) { super((Pointer)null); allocate(partId, triangleIndex, shape); } + private native void allocate(int partId, int triangleIndex, btCollisionShape shape); + + public native int getTriangleIndex(); + public native int getPartId(); + public native int getUid(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java index 8f897a9af2c..9cccdc7e7e2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btVertexBufferDescriptor.java @@ -23,11 +23,17 @@ public class btVertexBufferDescriptor extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btVertexBufferDescriptor(Pointer p) { super(p); } - /** enum btVertexBufferDescriptor::BufferTypes */ - public static final int - CPU_BUFFER = 0, - DX11_BUFFER = 1, - OPENGL_BUFFER = 2; + public enum BufferTypes { + CPU_BUFFER(0), + DX11_BUFFER(1), + OPENGL_BUFFER(2); + + public final int value; + private BufferTypes(int v) { this.value = v; } + private BufferTypes(BufferTypes e) { this.value = e.value; } + public BufferTypes intern() { for (BufferTypes e : values()) if (e.value == value) return e; return this; } + @Override public String toString() { return intern().name(); } + } public native @Cast("bool") boolean hasVertexPositions(); @@ -36,7 +42,7 @@ public class btVertexBufferDescriptor extends Pointer { /** * Return the type of the vertex buffer descriptor. */ - public native @Cast("btVertexBufferDescriptor::BufferTypes") int getBufferType(); + public native BufferTypes getBufferType(); /** * Return the vertex offset in floats from the base pointer. diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashInt_btVector3Array.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashInt_btVector3Array.java new file mode 100644 index 00000000000..010c3fc7996 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btHashMap_btHashInt_btVector3Array.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.LinearMath; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.LinearMath.*; + +@Name("btHashMap >") @Properties(inherit = org.bytedeco.bullet.presets.LinearMath.class) +public class btHashMap_btHashInt_btVector3Array extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public btHashMap_btHashInt_btVector3Array() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public btHashMap_btHashInt_btVector3Array(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public btHashMap_btHashInt_btVector3Array(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public btHashMap_btHashInt_btVector3Array position(long position) { + return (btHashMap_btHashInt_btVector3Array)super.position(position); + } + @Override public btHashMap_btHashInt_btVector3Array getPointer(long i) { + return new btHashMap_btHashInt_btVector3Array((Pointer)this).offsetAddress(i); + } + + public native void insert(@Const @ByRef btHashInt key, @Const @ByRef btVector3Array value); + + public native void remove(@Const @ByRef btHashInt key); + + public native int size(); + + public native btVector3Array getAtIndex(int index); + + public native @ByVal btHashInt getKeyAtIndex(int index); + + public native @Name("operator []") btVector3Array get(@Const @ByRef btHashInt key); + + public native btVector3Array find(@Const @ByRef btHashInt key); + + public native int findIndex(@Const @ByRef btHashInt key); + + public native void clear(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java index 5f344259732..5df070cf54e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletSoftBody.java @@ -59,6 +59,45 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #ifdef BT_USE_PLACEMENT_NEW // #include +// Targeting ../BulletSoftBody/LagrangeMultiplierArray.java + + +// Targeting ../BulletSoftBody/btDeformableFaceNodeContactConstraintArrayArray.java + + +// Targeting ../BulletSoftBody/btDeformableFaceRigidContactConstraintArrayArray.java + + +// Targeting ../BulletSoftBody/btDeformableNodeAnchorConstraintArrayArray.java + + +// Targeting ../BulletSoftBody/btDeformableNodeRigidContactConstraintArrayArray.java + + +// Targeting ../BulletSoftBody/btDeformableStaticConstraintArrayArray.java + + +// Targeting ../BulletSoftBody/btDeformableContactConstraintArray.java + + +// Targeting ../BulletSoftBody/btDeformableFaceNodeContactConstraintArray.java + + +// Targeting ../BulletSoftBody/btDeformableFaceRigidContactConstraintArray.java + + +// Targeting ../BulletSoftBody/btDeformableLagrangianForceArray.java + + +// Targeting ../BulletSoftBody/btDeformableNodeAnchorConstraintArray.java + + +// Targeting ../BulletSoftBody/btDeformableNodeRigidContactConstraintArray.java + + +// Targeting ../BulletSoftBody/btDeformableStaticConstraintArray.java + + // Targeting ../BulletSoftBody/btSoftBodyArray.java @@ -68,6 +107,18 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // Targeting ../BulletSoftBody/btSoftBodyClusterArray.java +// Targeting ../BulletSoftBody/btSoftBodyDeformableFaceNodeContactArray.java + + +// Targeting ../BulletSoftBody/btSoftBodyDeformableFaceRigidContactArray.java + + +// Targeting ../BulletSoftBody/btSoftBodyDeformableNodeRigidAnchorArray.java + + +// Targeting ../BulletSoftBody/btSoftBodyDeformableNodeRigidContactArray.java + + // Targeting ../BulletSoftBody/btSoftBodyFaceArray.java @@ -80,6 +131,9 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // Targeting ../BulletSoftBody/btSoftBodyMaterialArray.java +// Targeting ../BulletSoftBody/btSoftBodyNodePointerArray.java + + // Targeting ../BulletSoftBody/btSoftBodyNodeArray.java @@ -101,10 +155,177 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // Targeting ../BulletSoftBody/btSoftBodyTetraArray.java +// Targeting ../BulletSoftBody/btSoftBodyTetraSratchArray.java + + +// Targeting ../BulletSoftBody/btSparseSdf3CellArray.java + + // #endif //BT_OBJECT_ARRAY__ +// Parsed from BulletSoftBody/btSoftBody.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**btSoftBody implementation by Nathanael Presson */ + +// #ifndef _BT_SOFT_BODY_H +// #define _BT_SOFT_BODY_H + +// #include "LinearMath/btAlignedObjectArray.h" +// #include "LinearMath/btTransform.h" +// #include "LinearMath/btIDebugDraw.h" +// #include "LinearMath/btVector3.h" +// #include "BulletDynamics/Dynamics/btRigidBody.h" + +// #include "BulletCollision/CollisionShapes/btConcaveShape.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "btSparseSDF.h" +// #include "BulletCollision/BroadphaseCollision/btDbvt.h" +// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" +//#ifdef BT_USE_DOUBLE_PRECISION +//#define btRigidBodyData btRigidBodyDoubleData +//#define btRigidBodyDataName "btRigidBodyDoubleData" +//#else +// #define btSoftBodyData btSoftBodyFloatData +public static final String btSoftBodyDataName = "btSoftBodyFloatData"; +@MemberGetter public static native @Cast("const btScalar") float OVERLAP_REDUCTION_FACTOR(); +public static final float OVERLAP_REDUCTION_FACTOR = OVERLAP_REDUCTION_FACTOR(); +public static native @Cast("unsigned long") long seed(); public static native void seed(long setter); +//#endif //BT_USE_DOUBLE_PRECISION +// Targeting ../BulletSoftBody/btSoftBodyWorldInfo.java + + +// Targeting ../BulletSoftBody/btSoftBody.java + + + +// #endif //_BT_SOFT_BODY_H + + +// Parsed from BulletSoftBody/btCGProjection.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_CG_PROJECTION_H +// #define BT_CG_PROJECTION_H + +// #include "btSoftBody.h" +// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" +// Targeting ../BulletSoftBody/DeformableContactConstraint.java + + +// Targeting ../BulletSoftBody/btCGProjection.java + + + +// #endif /* btCGProjection_h */ + + +// Parsed from BulletSoftBody/btConjugateGradient.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_CONJUGATE_GRADIENT_H +// #define BT_CONJUGATE_GRADIENT_H +// #include "btKrylovSolver.h" +// #endif /* btConjugateGradient_h */ + + +// Parsed from BulletSoftBody/btConjugateResidual.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_CONJUGATE_RESIDUAL_H +// #define BT_CONJUGATE_RESIDUAL_H +// #include "btKrylovSolver.h" +// #endif /* btConjugateResidual_h */ + + +// Parsed from BulletSoftBody/btDefaultSoftBodySolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFT_BODY_DEFAULT_SOLVER_H +// #define BT_SOFT_BODY_DEFAULT_SOLVER_H + +// #include "BulletSoftBody/btSoftBodySolvers.h" +// #include "btSoftBodySolverVertexBuffer.h" +// Targeting ../BulletSoftBody/btDefaultSoftBodySolver.java + + + +// #endif // #ifndef BT_ACCELERATED_SOFT_BODY_CPU_SOLVER_H + + // Parsed from BulletSoftBody/btDeformableBackwardEulerObjective.h /* @@ -177,6 +398,87 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #endif /* btDeformableBodySolver_h */ +// Parsed from BulletSoftBody/btDeformableContactConstraint.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_CONTACT_CONSTRAINT_H +// #define BT_DEFORMABLE_CONTACT_CONSTRAINT_H +// #include "btSoftBody.h" +// Targeting ../BulletSoftBody/btDeformableContactConstraint.java + + +// Targeting ../BulletSoftBody/btDeformableStaticConstraint.java + + +// Targeting ../BulletSoftBody/btDeformableNodeAnchorConstraint.java + + +// Targeting ../BulletSoftBody/btDeformableRigidContactConstraint.java + + +// Targeting ../BulletSoftBody/btDeformableNodeRigidContactConstraint.java + + +// Targeting ../BulletSoftBody/btDeformableFaceRigidContactConstraint.java + + +// Targeting ../BulletSoftBody/btDeformableFaceNodeContactConstraint.java + + +// #endif /* BT_DEFORMABLE_CONTACT_CONSTRAINT_H */ + + +// Parsed from BulletSoftBody/btDeformableContactProjection.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_CONTACT_PROJECTION_H +// #define BT_CONTACT_PROJECTION_H +// #include "btCGProjection.h" +// #include "btSoftBody.h" +// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" +// #include "btDeformableContactConstraint.h" +// #include "LinearMath/btHashMap.h" +// #include "LinearMath/btReducedVector.h" +// #include "LinearMath/btModifiedGramSchmidt.h" +// #include +// Targeting ../BulletSoftBody/LagrangeMultiplier.java + + +// Targeting ../BulletSoftBody/btDeformableContactProjection.java + + +// #endif /* btDeformableContactProjection_h */ + + // Parsed from BulletSoftBody/btDeformableLagrangianForce.h /* @@ -194,154 +496,776 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_DEFORMABLE_LAGRANGIAN_FORCE_H -// #define BT_DEFORMABLE_LAGRANGIAN_FORCE_H +// #ifndef BT_DEFORMABLE_LAGRANGIAN_FORCE_H +// #define BT_DEFORMABLE_LAGRANGIAN_FORCE_H + +// #include "btSoftBody.h" +// #include +// #include + +/** enum btDeformableLagrangianForceType */ +public static final int + BT_GRAVITY_FORCE = 1, + BT_MASSSPRING_FORCE = 2, + BT_COROTATED_FORCE = 3, + BT_NEOHOOKEAN_FORCE = 4, + BT_LINEAR_ELASTICITY_FORCE = 5, + BT_MOUSE_PICKING_FORCE = 6; + +public static native double randomDouble(double low, double high); +// Targeting ../BulletSoftBody/btDeformableLagrangianForce.java + + +// #endif /* BT_DEFORMABLE_LAGRANGIAN_FORCE */ + + +// Parsed from BulletSoftBody/btDeformableCorotatedForce.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_COROTATED_H +// #define BT_COROTATED_H + +// #include "btDeformableLagrangianForce.h" +// #include "LinearMath/btPolarDecomposition.h" + +public static native int PolarDecomposition(@Const @ByRef btMatrix3x3 m, @ByRef btMatrix3x3 q, @ByRef btMatrix3x3 s); +// Targeting ../BulletSoftBody/btDeformableCorotatedForce.java + + + +// #endif /* btCorotated_h */ + + +// Parsed from BulletSoftBody/btDeformableGravityForce.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_GRAVITY_FORCE_H +// #define BT_DEFORMABLE_GRAVITY_FORCE_H + +// #include "btDeformableLagrangianForce.h" +// Targeting ../BulletSoftBody/btDeformableGravityForce.java + + +// #endif /* BT_DEFORMABLE_GRAVITY_FORCE_H */ + + +// Parsed from BulletSoftBody/btDeformableLinearElasticityForce.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_LINEAR_ELASTICITY_H +// #define BT_LINEAR_ELASTICITY_H + +// #include "btDeformableLagrangianForce.h" +// #include "LinearMath/btQuickprof.h" +// #include "btSoftBodyInternals.h" +public static final double TETRA_FLAT_THRESHOLD = 0.01; +// Targeting ../BulletSoftBody/btDeformableLinearElasticityForce.java + + +// #endif /* BT_LINEAR_ELASTICITY_H */ + + +// Parsed from BulletSoftBody/btDeformableMassSpringForce.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_MASS_SPRING_H +// #define BT_MASS_SPRING_H + +// #include "btDeformableLagrangianForce.h" +// Targeting ../BulletSoftBody/btDeformableMassSpringForce.java + + + +// #endif /* btMassSpring_h */ + + +// Parsed from BulletSoftBody/btDeformableMousePickingForce.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_MOUSE_PICKING_FORCE_H +// #define BT_MOUSE_PICKING_FORCE_H + +// #include "btDeformableLagrangianForce.h" +// Targeting ../BulletSoftBody/btDeformableMousePickingForce.java + + + +// #endif /* btMassSpring_h */ + + +// Parsed from BulletSoftBody/btDeformableMultiBodyConstraintSolver.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H +// #define BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H + +// #include "btDeformableBodySolver.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" +// Targeting ../BulletSoftBody/btDeformableMultiBodyConstraintSolver.java + + + +// #endif /* BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H */ + + +// Parsed from BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H +// #define BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H + +// #include "btSoftMultiBodyDynamicsWorld.h" +// #include "btDeformableLagrangianForce.h" +// #include "btDeformableMassSpringForce.h" +// #include "btDeformableBodySolver.h" +// #include "btDeformableMultiBodyConstraintSolver.h" +// #include "btSoftBodyHelpers.h" +// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" +// #include +// Targeting ../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java + + + +// #endif //BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H + + +// Parsed from BulletSoftBody/btDeformableNeoHookeanForce.h + +/* +Written by Xuchen Han + +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2019 Google Inc. http://bulletphysics.org +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_NEOHOOKEAN_H +// #define BT_NEOHOOKEAN_H + +// #include "btDeformableLagrangianForce.h" +// #include "LinearMath/btQuickprof.h" +// #include "LinearMath/btImplicitQRSVD.h" +// Targeting ../BulletSoftBody/btDeformableNeoHookeanForce.java + + +// #endif /* BT_NEOHOOKEAN_H */ + + +// Parsed from BulletSoftBody/btKrylovSolver.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_KRYLOV_SOLVER_H +// #define BT_KRYLOV_SOLVER_H +// #include +// #include +// #include +// #include +// #include +// #include +// #include "LinearMath/btQuickprof.h" +// #endif /* BT_KRYLOV_SOLVER_H */ + + +// Parsed from BulletSoftBody/btPreconditioner.h + +/* + Written by Xuchen Han + + Bullet Continuous Collision Detection and Physics Library + Copyright (c) 2019 Google Inc. http://bulletphysics.org + This software is provided 'as-is', without any express or implied warranty. + In no event will the authors be held liable for any damages arising from the use of this software. + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it freely, + subject to the following restrictions: + 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + */ + +// #ifndef BT_PRECONDITIONER_H +// #define BT_PRECONDITIONER_H +// Targeting ../BulletSoftBody/Preconditioner.java + + +// Targeting ../BulletSoftBody/DefaultPreconditioner.java + + +// Targeting ../BulletSoftBody/MassPreconditioner.java + + +// Targeting ../BulletSoftBody/KKTPreconditioner.java + + + +// #endif /* BT_PRECONDITIONER_H */ + + +// Parsed from BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H +// #define BT_SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H + +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" +// #include "BulletCollision/CollisionShapes/btTriangleCallback.h" +// #include "BulletCollision/NarrowPhaseCollision/btPersistentManifold.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" + +// #include "LinearMath/btHashMap.h" + +// #include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h" +// Targeting ../BulletSoftBody/btTriIndex.java + + +// Targeting ../BulletSoftBody/btSoftBodyTriangleCallback.java + + +// Targeting ../BulletSoftBody/btSoftBodyConcaveCollisionAlgorithm.java + + + +// #endif //BT_SOFT_BODY_CONCAVE_COLLISION_ALGORITHM_H + + +// Parsed from BulletSoftBody/btSoftBodyData.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFTBODY_FLOAT_DATA +// #define BT_SOFTBODY_FLOAT_DATA + +// #include "BulletCollision/CollisionDispatch/btCollisionObject.h" +// #include "BulletDynamics/Dynamics/btRigidBody.h" +// Targeting ../BulletSoftBody/SoftBodyMaterialData.java + + +// Targeting ../BulletSoftBody/SoftBodyNodeData.java + + +// Targeting ../BulletSoftBody/SoftBodyLinkData.java + + +// Targeting ../BulletSoftBody/SoftBodyFaceData.java + + +// Targeting ../BulletSoftBody/SoftBodyTetraData.java + + +// Targeting ../BulletSoftBody/SoftRigidAnchorData.java + + +// Targeting ../BulletSoftBody/SoftBodyConfigData.java + + +// Targeting ../BulletSoftBody/SoftBodyPoseData.java + + +// Targeting ../BulletSoftBody/SoftBodyClusterData.java + + + +/** enum btSoftJointBodyType */ +public static final int + BT_JOINT_SOFT_BODY_CLUSTER = 1, + BT_JOINT_RIGID_BODY = 2, + BT_JOINT_COLLISION_OBJECT = 3; +// Targeting ../BulletSoftBody/btSoftBodyJointData.java + + +// Targeting ../BulletSoftBody/btSoftBodyFloatData.java + + + +// #endif //BT_SOFTBODY_FLOAT_DATA + + +// Parsed from BulletSoftBody/btSoftBodyHelpers.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFT_BODY_HELPERS_H +// #define BT_SOFT_BODY_HELPERS_H + +// #include "btSoftBody.h" +// #include +// #include +// Targeting ../BulletSoftBody/fDrawFlags.java + + +// Targeting ../BulletSoftBody/btSoftBodyHelpers.java + + + +// #endif //BT_SOFT_BODY_HELPERS_H + + +// Parsed from BulletSoftBody/btSoftBodyInternals.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**btSoftBody implementation by Nathanael Presson */ + +// #ifndef _BT_SOFT_BODY_INTERNALS_H +// #define _BT_SOFT_BODY_INTERNALS_H + +// #include "btSoftBody.h" +// #include "LinearMath/btQuickprof.h" +// #include "LinearMath/btPolarDecomposition.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h" +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" +// #include "BulletCollision/CollisionShapes/btConvexInternalShape.h" +// #include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h" +// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" +// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" +// #include //for memset +// #include +// #include "poly34.h" + +// Given a multibody link, a contact point and a contact direction, fill in the jacobian data needed to calculate the velocity change given an impulse in the contact direction +public static native void findJacobian(@Const btMultiBodyLinkCollider multibodyLinkCol, + @ByRef btMultiBodyJacobianData jacobianData, + @Const @ByRef btVector3 contact_point, + @Const @ByRef btVector3 dir); +public static native @ByVal btVector3 generateUnitOrthogonalVector(@Const @ByRef btVector3 u); + +public static native @Cast("bool") boolean proximityTest(@Const @ByRef btVector3 x1, @Const @ByRef btVector3 x2, @Const @ByRef btVector3 x3, @Const @ByRef btVector3 x4, @Const @ByRef btVector3 normal, @Cast("const btScalar") float mrg, @ByRef btVector3 bary); +@MemberGetter public static native int KDOP_COUNT(); +public static final int KDOP_COUNT = KDOP_COUNT(); +public static native @ByRef btVector3 dop(int i); public static native void dop(int i, btVector3 setter); +@MemberGetter public static native btVector3 dop(); + +public static native int getSign(@Const @ByRef btVector3 n, @Const @ByRef btVector3 x); + +public static native @Cast("bool") boolean hasSeparatingPlane(@Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt); + +public static native @Cast("bool") boolean nearZero(@Cast("const btScalar") float a); +public static native @Cast("bool") boolean sameSign(@Cast("const btScalar") float a, @Cast("const btScalar") float b); +public static native @Cast("bool") boolean diffSign(@Cast("const btScalar") float a, @Cast("const btScalar") float b); +public static native @Cast("btScalar") float evaluateBezier2(@Cast("const btScalar") float p0, @Cast("const btScalar") float p1, @Cast("const btScalar") float p2, @Cast("const btScalar") float t, @Cast("const btScalar") float s); +public static native @Cast("btScalar") float evaluateBezier(@Cast("const btScalar") float p0, @Cast("const btScalar") float p1, @Cast("const btScalar") float p2, @Cast("const btScalar") float p3, @Cast("const btScalar") float t, @Cast("const btScalar") float s); +public static native @Cast("bool") boolean getSigns(@Cast("bool") boolean type_c, @Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float t0, @Cast("const btScalar") float t1, @Cast("btScalar*") @ByRef FloatPointer lt0, @Cast("btScalar*") @ByRef FloatPointer lt1); +public static native @Cast("bool") boolean getSigns(@Cast("bool") boolean type_c, @Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float t0, @Cast("const btScalar") float t1, @Cast("btScalar*") @ByRef FloatBuffer lt0, @Cast("btScalar*") @ByRef FloatBuffer lt1); +public static native @Cast("bool") boolean getSigns(@Cast("bool") boolean type_c, @Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float t0, @Cast("const btScalar") float t1, @Cast("btScalar*") @ByRef float[] lt0, @Cast("btScalar*") @ByRef float[] lt1); + +public static native void getBernsteinCoeff(@Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt, @Cast("btScalar*") @ByRef FloatPointer k0, @Cast("btScalar*") @ByRef FloatPointer k1, @Cast("btScalar*") @ByRef FloatPointer k2, @Cast("btScalar*") @ByRef FloatPointer k3); +public static native void getBernsteinCoeff(@Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt, @Cast("btScalar*") @ByRef FloatBuffer k0, @Cast("btScalar*") @ByRef FloatBuffer k1, @Cast("btScalar*") @ByRef FloatBuffer k2, @Cast("btScalar*") @ByRef FloatBuffer k3); +public static native void getBernsteinCoeff(@Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt, @Cast("btScalar*") @ByRef float[] k0, @Cast("btScalar*") @ByRef float[] k1, @Cast("btScalar*") @ByRef float[] k2, @Cast("btScalar*") @ByRef float[] k3); + +public static native void polyDecomposition(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float j0, @Cast("const btScalar") float j1, @Cast("const btScalar") float j2, @Cast("btScalar*") @ByRef FloatPointer u0, @Cast("btScalar*") @ByRef FloatPointer u1, @Cast("btScalar*") @ByRef FloatPointer v0, @Cast("btScalar*") @ByRef FloatPointer v1); +public static native void polyDecomposition(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float j0, @Cast("const btScalar") float j1, @Cast("const btScalar") float j2, @Cast("btScalar*") @ByRef FloatBuffer u0, @Cast("btScalar*") @ByRef FloatBuffer u1, @Cast("btScalar*") @ByRef FloatBuffer v0, @Cast("btScalar*") @ByRef FloatBuffer v1); +public static native void polyDecomposition(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float j0, @Cast("const btScalar") float j1, @Cast("const btScalar") float j2, @Cast("btScalar*") @ByRef float[] u0, @Cast("btScalar*") @ByRef float[] u1, @Cast("btScalar*") @ByRef float[] v0, @Cast("btScalar*") @ByRef float[] v1); + +public static native @Cast("bool") boolean rootFindingLemma(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3); + +public static native void getJs(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Const btSoftBody.Node a, @Const btSoftBody.Node b, @Const btSoftBody.Node c, @Const btSoftBody.Node p, @Cast("const btScalar") float dt, @Cast("btScalar*") @ByRef FloatPointer j0, @Cast("btScalar*") @ByRef FloatPointer j1, @Cast("btScalar*") @ByRef FloatPointer j2); +public static native void getJs(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Const btSoftBody.Node a, @Const btSoftBody.Node b, @Const btSoftBody.Node c, @Const btSoftBody.Node p, @Cast("const btScalar") float dt, @Cast("btScalar*") @ByRef FloatBuffer j0, @Cast("btScalar*") @ByRef FloatBuffer j1, @Cast("btScalar*") @ByRef FloatBuffer j2); +public static native void getJs(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Const btSoftBody.Node a, @Const btSoftBody.Node b, @Const btSoftBody.Node c, @Const btSoftBody.Node p, @Cast("const btScalar") float dt, @Cast("btScalar*") @ByRef float[] j0, @Cast("btScalar*") @ByRef float[] j1, @Cast("btScalar*") @ByRef float[] j2); + +public static native @Cast("bool") boolean signDetermination1Internal(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float u0, @Cast("const btScalar") float u1, @Cast("const btScalar") float v0, @Cast("const btScalar") float v1); + +public static native @Cast("bool") boolean signDetermination2Internal(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float j0, @Cast("const btScalar") float j1, @Cast("const btScalar") float j2, @Cast("const btScalar") float u0, @Cast("const btScalar") float u1, @Cast("const btScalar") float v0, @Cast("const btScalar") float v1); + +public static native @Cast("bool") boolean signDetermination1(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt); + +public static native @Cast("bool") boolean signDetermination2(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt); + +public static native @Cast("bool") boolean coplanarAndInsideTest(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt); +public static native @Cast("bool") boolean conservativeCulling(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float mrg); -// #include "btSoftBody.h" -// #include -// #include +public static native @Cast("bool") boolean bernsteinVFTest(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float mrg, @Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt); -/** enum btDeformableLagrangianForceType */ -public static final int - BT_GRAVITY_FORCE = 1, - BT_MASSSPRING_FORCE = 2, - BT_COROTATED_FORCE = 3, - BT_NEOHOOKEAN_FORCE = 4, - BT_LINEAR_ELASTICITY_FORCE = 5, - BT_MOUSE_PICKING_FORCE = 6; +public static native void deCasteljau(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float t0, @Cast("btScalar*") @ByRef FloatPointer k10, @Cast("btScalar*") @ByRef FloatPointer k20, @Cast("btScalar*") @ByRef FloatPointer k30, @Cast("btScalar*") @ByRef FloatPointer k21, @Cast("btScalar*") @ByRef FloatPointer k12); +public static native void deCasteljau(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float t0, @Cast("btScalar*") @ByRef FloatBuffer k10, @Cast("btScalar*") @ByRef FloatBuffer k20, @Cast("btScalar*") @ByRef FloatBuffer k30, @Cast("btScalar*") @ByRef FloatBuffer k21, @Cast("btScalar*") @ByRef FloatBuffer k12); +public static native void deCasteljau(@Cast("const btScalar") float k0, @Cast("const btScalar") float k1, @Cast("const btScalar") float k2, @Cast("const btScalar") float k3, @Cast("const btScalar") float t0, @Cast("btScalar*") @ByRef float[] k10, @Cast("btScalar*") @ByRef float[] k20, @Cast("btScalar*") @ByRef float[] k30, @Cast("btScalar*") @ByRef float[] k21, @Cast("btScalar*") @ByRef float[] k12); +public static native @Cast("bool") boolean bernsteinVFTest(@Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt, @Cast("const btScalar") float mrg); -public static native double randomDouble(double low, double high); -// Targeting ../BulletSoftBody/btDeformableLagrangianForce.java +public static native @Cast("bool") boolean continuousCollisionDetection(@Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt, @Cast("const btScalar") float mrg, @ByRef btVector3 bary); +public static native @Cast("bool") boolean bernsteinCCD(@Const btSoftBody.Face face, @Const btSoftBody.Node node, @Cast("const btScalar") float dt, @Cast("const btScalar") float mrg, @ByRef btVector3 bary); +// +// btSymMatrix +// +// Targeting ../BulletSoftBody/btSoftBodyCollisionShape.java -// #endif /* BT_DEFORMABLE_LAGRANGIAN_FORCE */ +// Targeting ../BulletSoftBody/btSoftClusterCollisionShape.java -// Parsed from BulletSoftBody/btDeformableMultiBodyConstraintSolver.h -/* - Written by Xuchen Han - - Bullet Continuous Collision Detection and Physics Library - Copyright (c) 2019 Google Inc. http://bulletphysics.org - This software is provided 'as-is', without any express or implied warranty. - In no event will the authors be held liable for any damages arising from the use of this software. - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it freely, - subject to the following restrictions: - 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - */ -// #ifndef BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H -// #define BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H +// +// Inline's +// -// #include "btDeformableBodySolver.h" -// #include "BulletDynamics/Featherstone/btMultiBodyConstraintSolver.h" -// Targeting ../BulletSoftBody/btDeformableMultiBodyConstraintSolver.java +// +// +// +// +// +// +public static native @ByVal btMatrix3x3 Lerp(@Const @ByRef btMatrix3x3 a, + @Const @ByRef btMatrix3x3 b, + @Cast("btScalar") float t); +// +public static native @ByVal btVector3 Clamp(@Const @ByRef btVector3 v, @Cast("btScalar") float maxlength); +// +// +// +// +// +// +public static native @Cast("btScalar") float ClusterMetric(@Const @ByRef btVector3 x, @Const @ByRef btVector3 y); +// +public static native @ByVal btMatrix3x3 ScaleAlongAxis(@Const @ByRef btVector3 a, @Cast("btScalar") float s); +// +public static native @ByVal btMatrix3x3 Cross(@Const @ByRef btVector3 v); +// +public static native @ByVal btMatrix3x3 Diagonal(@Cast("btScalar") float x); +public static native @ByVal btMatrix3x3 Diagonal(@Const @ByRef btVector3 v); +public static native @Cast("btScalar") float Dot(@Cast("const btScalar*") FloatPointer a, @Cast("const btScalar*") FloatPointer b, int ndof); +public static native @Cast("btScalar") float Dot(@Cast("const btScalar*") FloatBuffer a, @Cast("const btScalar*") FloatBuffer b, int ndof); +public static native @Cast("btScalar") float Dot(@Cast("const btScalar*") float[] a, @Cast("const btScalar*") float[] b, int ndof); -// #endif /* BT_DEFORMABLE_MULTIBODY_CONSTRAINT_SOLVER_H */ +public static native @ByVal btMatrix3x3 OuterProduct(@Cast("const btScalar*") FloatPointer v1, @Cast("const btScalar*") FloatPointer v2, @Cast("const btScalar*") FloatPointer v3, + @Cast("const btScalar*") FloatPointer u1, @Cast("const btScalar*") FloatPointer u2, @Cast("const btScalar*") FloatPointer u3, int ndof); +public static native @ByVal btMatrix3x3 OuterProduct(@Cast("const btScalar*") FloatBuffer v1, @Cast("const btScalar*") FloatBuffer v2, @Cast("const btScalar*") FloatBuffer v3, + @Cast("const btScalar*") FloatBuffer u1, @Cast("const btScalar*") FloatBuffer u2, @Cast("const btScalar*") FloatBuffer u3, int ndof); +public static native @ByVal btMatrix3x3 OuterProduct(@Cast("const btScalar*") float[] v1, @Cast("const btScalar*") float[] v2, @Cast("const btScalar*") float[] v3, + @Cast("const btScalar*") float[] u1, @Cast("const btScalar*") float[] u2, @Cast("const btScalar*") float[] u3, int ndof); +public static native @ByVal btMatrix3x3 OuterProduct(@Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2); -// Parsed from BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h +// +public static native @ByVal btMatrix3x3 Add(@Const @ByRef btMatrix3x3 a, + @Const @ByRef btMatrix3x3 b); +// +public static native @ByVal btMatrix3x3 Sub(@Const @ByRef btMatrix3x3 a, + @Const @ByRef btMatrix3x3 b); +// +public static native @ByVal btMatrix3x3 Mul(@Const @ByRef btMatrix3x3 a, + @Cast("btScalar") float b); +// +public static native void Orthogonalize(@ByRef btMatrix3x3 m); +// +public static native @ByVal btMatrix3x3 MassMatrix(@Cast("btScalar") float im, @Const @ByRef btMatrix3x3 iwi, @Const @ByRef btVector3 r); -/* - Written by Xuchen Han - - Bullet Continuous Collision Detection and Physics Library - Copyright (c) 2019 Google Inc. http://bulletphysics.org - This software is provided 'as-is', without any express or implied warranty. - In no event will the authors be held liable for any damages arising from the use of this software. - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it freely, - subject to the following restrictions: - 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - */ +// +public static native @ByVal btMatrix3x3 ImpulseMatrix(@Cast("btScalar") float dt, + @Cast("btScalar") float ima, + @Cast("btScalar") float imb, + @Const @ByRef btMatrix3x3 iwi, + @Const @ByRef btVector3 r); -// #ifndef BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H -// #define BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H +// +public static native @ByVal btMatrix3x3 ImpulseMatrix(@Cast("btScalar") float dt, + @Const @ByRef btMatrix3x3 effective_mass_inv, + @Cast("btScalar") float imb, + @Const @ByRef btMatrix3x3 iwi, + @Const @ByRef btVector3 r); -// #include "btSoftMultiBodyDynamicsWorld.h" -// #include "btDeformableLagrangianForce.h" -// #include "btDeformableMassSpringForce.h" -// #include "btDeformableBodySolver.h" -// #include "btDeformableMultiBodyConstraintSolver.h" -// #include "btSoftBodyHelpers.h" -// #include "BulletCollision/CollisionDispatch/btSimulationIslandManager.h" -// #include -// Targeting ../BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java +// +public static native @ByVal btMatrix3x3 ImpulseMatrix(@Cast("btScalar") float ima, @Const @ByRef btMatrix3x3 iia, @Const @ByRef btVector3 ra, + @Cast("btScalar") float imb, @Const @ByRef btMatrix3x3 iib, @Const @ByRef btVector3 rb); +// +public static native @ByVal btMatrix3x3 AngularImpulseMatrix(@Const @ByRef btMatrix3x3 iia, + @Const @ByRef btMatrix3x3 iib); -// Targeting ../BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java +// +public static native @ByVal btVector3 ProjectOnAxis(@Const @ByRef btVector3 v, + @Const @ByRef btVector3 a); +// +public static native @ByVal btVector3 ProjectOnPlane(@Const @ByRef btVector3 v, + @Const @ByRef btVector3 a); +// +public static native void ProjectOrigin(@Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @ByRef btVector3 prj, + @Cast("btScalar*") @ByRef FloatPointer sqd); +public static native void ProjectOrigin(@Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @ByRef btVector3 prj, + @Cast("btScalar*") @ByRef FloatBuffer sqd); +public static native void ProjectOrigin(@Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @ByRef btVector3 prj, + @Cast("btScalar*") @ByRef float[] sqd); +// +public static native void ProjectOrigin(@Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @Const @ByRef btVector3 c, + @ByRef btVector3 prj, + @Cast("btScalar*") @ByRef FloatPointer sqd); +public static native void ProjectOrigin(@Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @Const @ByRef btVector3 c, + @ByRef btVector3 prj, + @Cast("btScalar*") @ByRef FloatBuffer sqd); +public static native void ProjectOrigin(@Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @Const @ByRef btVector3 c, + @ByRef btVector3 prj, + @Cast("btScalar*") @ByRef float[] sqd); +// +public static native @Cast("bool") boolean rayIntersectsTriangle(@Const @ByRef btVector3 origin, @Const @ByRef btVector3 dir, @Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Cast("btScalar*") @ByRef FloatPointer t); +public static native @Cast("bool") boolean rayIntersectsTriangle(@Const @ByRef btVector3 origin, @Const @ByRef btVector3 dir, @Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Cast("btScalar*") @ByRef FloatBuffer t); +public static native @Cast("bool") boolean rayIntersectsTriangle(@Const @ByRef btVector3 origin, @Const @ByRef btVector3 dir, @Const @ByRef btVector3 v0, @Const @ByRef btVector3 v1, @Const @ByRef btVector3 v2, @Cast("btScalar*") @ByRef float[] t); -// #endif //BT_DEFORMABLE_MULTIBODY_DYNAMICS_WORLD_H +public static native @Cast("bool") boolean lineIntersectsTriangle(@Const @ByRef btVector3 rayStart, @Const @ByRef btVector3 rayEnd, @Const @ByRef btVector3 p1, @Const @ByRef btVector3 p2, @Const @ByRef btVector3 p3, @ByRef btVector3 sect, @ByRef btVector3 normal); +// +// +public static native @ByVal btVector3 BaryCoord(@Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @Const @ByRef btVector3 c, + @Const @ByRef btVector3 p); -// Parsed from BulletSoftBody/btSoftBody.h +// +public static native @Cast("btScalar") float ImplicitSolve(btSoftBody.ImplicitFn fn, + @Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @Cast("const btScalar") float accuracy, + int maxiterations/*=256*/); +public static native @Cast("btScalar") float ImplicitSolve(btSoftBody.ImplicitFn fn, + @Const @ByRef btVector3 a, + @Const @ByRef btVector3 b, + @Cast("const btScalar") float accuracy); + +public static native void EvaluateMedium(@Const btSoftBodyWorldInfo wfi, + @Const @ByRef btVector3 x, + @ByRef btSoftBody.sMedium medium); -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org +// +public static native @ByVal btVector3 NormalizeAny(@Const @ByRef btVector3 v); -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: +// +public static native @ByVal @Cast("btDbvtVolume*") btDbvtAabbMm VolumeOf(@Const @ByRef btSoftBody.Face f, + @Cast("btScalar") float margin); -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ -/**btSoftBody implementation by Nathanael Presson */ +// +public static native @ByVal btVector3 CenterOf(@Const @ByRef btSoftBody.Face f); -// #ifndef _BT_SOFT_BODY_H -// #define _BT_SOFT_BODY_H +// +public static native @Cast("btScalar") float AreaOf(@Const @ByRef btVector3 x0, + @Const @ByRef btVector3 x1, + @Const @ByRef btVector3 x2); -// #include "LinearMath/btAlignedObjectArray.h" -// #include "LinearMath/btTransform.h" -// #include "LinearMath/btIDebugDraw.h" -// #include "LinearMath/btVector3.h" -// #include "BulletDynamics/Dynamics/btRigidBody.h" +// +public static native @Cast("btScalar") float VolumeOf(@Const @ByRef btVector3 x0, + @Const @ByRef btVector3 x1, + @Const @ByRef btVector3 x2, + @Const @ByRef btVector3 x3); -// #include "BulletCollision/CollisionShapes/btConcaveShape.h" -// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" -// #include "btSparseSDF.h" -// #include "BulletCollision/BroadphaseCollision/btDbvt.h" -// #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h" -// #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h" -//#ifdef BT_USE_DOUBLE_PRECISION -//#define btRigidBodyData btRigidBodyDoubleData -//#define btRigidBodyDataName "btRigidBodyDoubleData" -//#else -// #define btSoftBodyData btSoftBodyFloatData -public static final String btSoftBodyDataName = "btSoftBodyFloatData"; -@MemberGetter public static native @Cast("const btScalar") float OVERLAP_REDUCTION_FACTOR(); -public static final float OVERLAP_REDUCTION_FACTOR = OVERLAP_REDUCTION_FACTOR(); -public static native @Cast("unsigned long") long seed(); public static native void seed(long setter); -//#endif //BT_USE_DOUBLE_PRECISION -// Targeting ../BulletSoftBody/btSoftBodyWorldInfo.java +// +// +public static native void ApplyClampedForce(@ByRef btSoftBody.Node n, + @Const @ByRef btVector3 f, + @Cast("btScalar") float dt); -// Targeting ../BulletSoftBody/btSoftBody.java +// +public static native int MatchEdge(@Const btSoftBody.Node a, + @Const btSoftBody.Node b, + @Const btSoftBody.Node ma, + @Const btSoftBody.Node mb); +// Targeting ../BulletSoftBody/btEigen.java -// #endif //_BT_SOFT_BODY_H +// +// Polar decomposition, +// "Computing the Polar Decomposition with Applications", Nicholas J. Higham, 1986. +// +public static native int PolarDecompose(@Const @ByRef btMatrix3x3 m, @ByRef btMatrix3x3 q, @ByRef btMatrix3x3 s); +// Targeting ../BulletSoftBody/btSoftColliders.java -// Parsed from BulletSoftBody/btSoftBodyHelpers.h +// #endif //_BT_SOFT_BODY_INTERNALS_H + + +// Parsed from BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h /* Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. @@ -354,23 +1278,18 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOFT_BODY_HELPERS_H -// #define BT_SOFT_BODY_HELPERS_H - -// #include "btSoftBody.h" -// #include -// #include -// Targeting ../BulletSoftBody/fDrawFlags.java - +// #ifndef BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION +// #define BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION -// Targeting ../BulletSoftBody/btSoftBodyHelpers.java +// #include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" +// Targeting ../BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java -// #endif //BT_SOFT_BODY_HELPERS_H +// #endif //BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION -// Parsed from BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h +// Parsed from BulletSoftBody/btSoftBodySolvers.h /* Bullet Continuous Collision Detection and Physics Library @@ -387,15 +1306,27 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION -// #define BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION +// #ifndef BT_SOFT_BODY_SOLVERS_H +// #define BT_SOFT_BODY_SOLVERS_H -// #include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h" -// Targeting ../BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.java +// #include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h" +// Targeting ../BulletSoftBody/btSoftBodyTriangleData.java +// Targeting ../BulletSoftBody/btSoftBodyLinkData.java + + +// Targeting ../BulletSoftBody/btSoftBodyVertexData.java + + +// Targeting ../BulletSoftBody/btSoftBodySolver.java + + +// Targeting ../BulletSoftBody/btSoftBodySolverOutput.java + -// #endif //BT_SOFTBODY_RIGIDBODY_COLLISION_CONFIGURATION + +// #endif // #ifndef BT_SOFT_BODY_SOLVERS_H // Parsed from BulletSoftBody/btSoftBodySolverVertexBuffer.h @@ -427,7 +1358,7 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #endif // #ifndef BT_SOFT_BODY_SOLVER_VERTEX_BUFFER_H -// Parsed from BulletSoftBody/btSoftBodySolvers.h +// Parsed from BulletSoftBody/btSoftMultiBodyDynamicsWorld.h /* Bullet Continuous Collision Detection and Physics Library @@ -444,21 +1375,22 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOFT_BODY_SOLVERS_H -// #define BT_SOFT_BODY_SOLVERS_H - -// #include "BulletCollision/CollisionShapes/btTriangleIndexVertexArray.h" -// Targeting ../BulletSoftBody/btSoftBodySolver.java +// #ifndef BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H +// #define BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H +// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" +// #include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h" +// #include "BulletSoftBody/btSoftBody.h" -// Targeting ../BulletSoftBody/btSoftBodySolverOutput.java +// #ifndef BT_SOFT_RIGID_DYNAMICS_WORLD_H +// Targeting ../BulletSoftBody/btSoftMultiBodyDynamicsWorld.java -// #endif // #ifndef BT_SOFT_BODY_SOLVERS_H +// #endif //BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H -// Parsed from BulletSoftBody/btSoftMultiBodyDynamicsWorld.h +// Parsed from BulletSoftBody/btSoftRigidCollisionAlgorithm.h /* Bullet Continuous Collision Detection and Physics Library @@ -475,19 +1407,20 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { 3. This notice may not be removed or altered from any source distribution. */ -// #ifndef BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H -// #define BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H +// #ifndef BT_SOFT_RIGID_COLLISION_ALGORITHM_H +// #define BT_SOFT_RIGID_COLLISION_ALGORITHM_H -// #include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h" -// #include "BulletDynamics/Featherstone/btMultiBodyDynamicsWorld.h" -// #include "BulletSoftBody/btSoftBody.h" +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// #include "BulletCollision/CollisionDispatch/btCollisionDispatcher.h" -// #ifndef BT_SOFT_RIGID_DYNAMICS_WORLD_H -// Targeting ../BulletSoftBody/btSoftMultiBodyDynamicsWorld.java +// #include "LinearMath/btVector3.h" +// Targeting ../BulletSoftBody/btSoftRigidCollisionAlgorithm.java -// #endif //BT_SOFT_MULTIBODY_DYNAMICS_WORLD_H +// #endif //BT_SOFT_RIGID_COLLISION_ALGORITHM_H // Parsed from BulletSoftBody/btSoftRigidDynamicsWorld.h @@ -519,6 +1452,37 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // #endif //BT_SOFT_RIGID_DYNAMICS_WORLD_H +// Parsed from BulletSoftBody/btSoftSoftCollisionAlgorithm.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef BT_SOFT_SOFT_COLLISION_ALGORITHM_H +// #define BT_SOFT_SOFT_COLLISION_ALGORITHM_H + +// #include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h" +// #include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" +// #include "BulletCollision/BroadphaseCollision/btDispatcher.h" +// #include "BulletCollision/CollisionDispatch/btCollisionCreateFunc.h" +// Targeting ../BulletSoftBody/btSoftSoftCollisionAlgorithm.java + + + +// #endif //BT_SOFT_SOFT_COLLISION_ALGORITHM_H + + // Parsed from BulletSoftBody/btSparseSDF.h /* @@ -553,11 +1517,29 @@ public class BulletSoftBody extends org.bytedeco.bullet.presets.BulletSoftBody { // public static native @Cast("unsigned int") int HsiehHash(@Cast("const char*") BytePointer data, int len); public static native @Cast("unsigned int") int HsiehHash(String data, int len); -// Targeting ../BulletSoftBody/btSparseSdf_3.java +// Targeting ../BulletSoftBody/btSparseSdf3.java // #endif //BT_SPARSE_SDF_H +// Parsed from BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.h + +// +// DeformableBodyInplaceSolverIslandCallback.h +// BulletSoftBody +// +// Created by Xuchen Han on 12/16/19. +// + +// #ifndef DeformableBodyInplaceSolverIslandCallback_h +// #define DeformableBodyInplaceSolverIslandCallback_h +// Targeting ../BulletSoftBody/DeformableBodyInplaceSolverIslandCallback.java + + + +// #endif /* DeformableBodyInplaceSolverIslandCallback_h */ + + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java index d5a986bd87d..33edabadaf4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/LinearMath.java @@ -804,6 +804,9 @@ SIMD_FORCE_INLINE btMatrix3x3 btMultTransposeLeft(const btMatrix3x3& m1, const b // Targeting ../LinearMath/btHashMap_btHashPtr_voidPointer.java +// Targeting ../LinearMath/btHashMap_btHashInt_btVector3Array.java + + // #endif //BT_HASH_MAP_H From 3d8e12872539e3233d2b13ef90ff1dc0a472bfba Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Mar 2022 18:44:18 +0800 Subject: [PATCH 57/81] Skip undefined symbols --- .../java/org/bytedeco/bullet/presets/BulletDynamics.java | 6 +++++- .../java/org/bytedeco/bullet/presets/BulletSoftBody.java | 2 ++ .../main/java/org/bytedeco/bullet/presets/LinearMath.java | 4 +++- 3 files changed, 10 insertions(+), 2 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java index 6225a347989..0789e2c6791 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletDynamics.java @@ -184,7 +184,11 @@ public void map(InfoMap infoMap) { "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", - "btDantzigScratchMemory::Arows" + "btDantzigScratchMemory::Arows", + "btSequentialImpulseConstraintSolver::getSSE2ConstraintRowSolverGeneric", + "btSequentialImpulseConstraintSolver::getSSE2ConstraintRowSolverLowerLimit", + "btSequentialImpulseConstraintSolver::getSSE4_1ConstraintRowSolverGeneric", + "btSequentialImpulseConstraintSolver::getSSE4_1ConstraintRowSolverLowerLimit" ).skip()) ; } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java index 58046f23f4f..8dd248b6cc8 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletSoftBody.java @@ -261,6 +261,8 @@ public void map(InfoMap infoMap) { "btAlignedObjectArray::findLinearSearch", "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", + "btDeformableBackwardEulerObjective::computeStep", + "btDeformableMultiBodyDynamicsWorld::solveMultiBodyConstraints", "btDeformableMultiBodyDynamicsWorld::rayTestSingle", "btSoftBody::AJoint::Type", "btSoftBody::CJoint::Type", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java index 288d3930f4e..e68bcd10d0f 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/LinearMath.java @@ -173,8 +173,10 @@ public void map(InfoMap infoMap) { "btAlignedObjectArray::findLinearSearch2", "btAlignedObjectArray::remove", "btBulletSerializedArrays", + "btGeometryUtil::isInside", "btGetInfinityMask", - "btInfMaskConverter" + "btInfMaskConverter", + "btThreadSupportInterface::create" ).skip()) ; } From 668a0bade77606e062e9dc80ac5358b4da1fb897 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Mar 2022 18:44:51 +0800 Subject: [PATCH 58/81] Update generated code of bullet preset See parent commit. --- .../btSequentialImpulseConstraintSolver.java | 8 ++++---- .../btDeformableBackwardEulerObjective.java | 2 +- .../btDeformableMultiBodyDynamicsWorld.java | 2 +- .../org/bytedeco/bullet/LinearMath/btGeometryUtil.java | 2 +- .../bullet/LinearMath/btThreadSupportInterface.java | 2 +- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java index 1741d639c27..8b06776e576 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletDynamics/btSequentialImpulseConstraintSolver.java @@ -59,12 +59,12 @@ public class btSequentialImpulseConstraintSolver extends btConstraintSolver { /**Various implementations of solving a single constraint row using a generic equality constraint, using scalar reference, SSE2 or SSE4 */ public native btSingleConstraintRowSolver getScalarConstraintRowSolverGeneric(); - public native btSingleConstraintRowSolver getSSE2ConstraintRowSolverGeneric(); - public native btSingleConstraintRowSolver getSSE4_1ConstraintRowSolverGeneric(); + + /**Various implementations of solving a single constraint row using an inequality (lower limit) constraint, using scalar reference, SSE2 or SSE4 */ public native btSingleConstraintRowSolver getScalarConstraintRowSolverLowerLimit(); - public native btSingleConstraintRowSolver getSSE2ConstraintRowSolverLowerLimit(); - public native btSingleConstraintRowSolver getSSE4_1ConstraintRowSolverLowerLimit(); + + public native @ByRef btSolverAnalyticsData m_analyticsData(); public native btSequentialImpulseConstraintSolver m_analyticsData(btSolverAnalyticsData setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java index 287200e3235..38eab34d7ef 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableBackwardEulerObjective.java @@ -52,7 +52,7 @@ public class btDeformableBackwardEulerObjective extends Pointer { public native @Cast("btScalar") float computeNorm(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array residual); // compute one step of the solve (there is only one solve if the system is linear) - public native void computeStep(@Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array dv, @Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array residual, @Cast("const btScalar") float dt); + // perform A*x = b public native void multiply(@Cast("const btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array x, @Cast("btDeformableBackwardEulerObjective::TVStack*") @ByRef btVector3Array b); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java index 5d4d139fe34..0d69b6c6493 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.java @@ -80,7 +80,7 @@ public static class btSolverCallback extends FunctionPointer { public native void performDeformableCollisionDetection(); - public native void solveMultiBodyConstraints(); + public native void solveContactConstraints(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btGeometryUtil.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btGeometryUtil.java index 2ad5e1136e1..7afce23e6bf 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btGeometryUtil.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btGeometryUtil.java @@ -34,7 +34,7 @@ public class btGeometryUtil extends Pointer { public static native void getVerticesFromPlaneEquations(@Const @ByRef btVector3Array planeEquations, @ByRef btVector3Array verticesOut); - public static native @Cast("bool") boolean isInside(@Const @ByRef btVector3Array vertices, @Const @ByRef btVector3 planeNormal, @Cast("btScalar") float margin); + public static native @Cast("bool") boolean isPointInsidePlanes(@Const @ByRef btVector3Array planeEquations, @Const @ByRef btVector3 point, @Cast("btScalar") float margin); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btThreadSupportInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btThreadSupportInterface.java index b889526c72d..51b27ccb5a6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btThreadSupportInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/LinearMath/btThreadSupportInterface.java @@ -67,5 +67,5 @@ private native void allocate(String uniqueName, public native int m_threadStackSize(); public native ConstructionInfo m_threadStackSize(int setter); } - public static native btThreadSupportInterface create(@Const @ByRef ConstructionInfo info); + } From 8bb57930f53ad659abdb627d8bccc237d802a8c1 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Sun, 13 Mar 2022 19:19:51 +0800 Subject: [PATCH 59/81] Rename GIM_* arrays *_ARRAY.java and _Array.java file names conflict on Windows. --- .../java/org/bytedeco/bullet/presets/BulletCollision.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java index f19e862facd..c36fd702776 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/BulletCollision.java @@ -202,10 +202,10 @@ public void map(InfoMap infoMap) { ).define(false)) .put(new Info("btAlignedObjectArray").pointerTypes("BT_QUANTIZED_BVH_NODE_Array")) - .put(new Info("btAlignedObjectArray").pointerTypes("GIM_BVH_DATA_Array")) - .put(new Info("btAlignedObjectArray").pointerTypes("GIM_BVH_TREE_NODE_Array")) - .put(new Info("btAlignedObjectArray").pointerTypes("GIM_CONTACT_Array")) - .put(new Info("btAlignedObjectArray").pointerTypes("GIM_PAIR_Array")) + .put(new Info("btAlignedObjectArray").pointerTypes("GIM_BVH_DATA_Array_")) + .put(new Info("btAlignedObjectArray").pointerTypes("GIM_BVH_TREE_NODE_Array_")) + .put(new Info("btAlignedObjectArray").pointerTypes("GIM_CONTACT_Array_")) + .put(new Info("btAlignedObjectArray").pointerTypes("GIM_PAIR_Array_")) .put(new Info("btAlignedObjectArray >").pointerTypes("btCell32ArrayArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btBvhSubtreeInfoArray")) .put(new Info("btAlignedObjectArray").pointerTypes("btCell32Array")) From 5a6866d997d2d6ebe4625f3e4d82a71054998daa Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 14 Mar 2022 00:05:01 +0800 Subject: [PATCH 60/81] Update generated code of bullet preset See parent commit. --- .../BulletCollision/GIM_BVH_DATA_ARRAY.java | 2 +- ...TA_Array.java => GIM_BVH_DATA_Array_.java} | 24 +++++++++---------- .../GIM_BVH_TREE_NODE_ARRAY.java | 2 +- ...ray.java => GIM_BVH_TREE_NODE_Array_.java} | 24 +++++++++---------- ...ACT_Array.java => GIM_CONTACT_Array_.java} | 24 +++++++++---------- ...M_PAIR_Array.java => GIM_PAIR_Array_.java} | 24 +++++++++---------- .../BulletCollision/btContactArray.java | 2 +- .../bullet/BulletCollision/btPairSet.java | 2 +- .../bullet/global/BulletCollision.java | 8 +++---- 9 files changed, 56 insertions(+), 56 deletions(-) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{GIM_BVH_DATA_Array.java => GIM_BVH_DATA_Array_.java} (77%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{GIM_BVH_TREE_NODE_Array.java => GIM_BVH_TREE_NODE_Array_.java} (80%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{GIM_CONTACT_Array.java => GIM_CONTACT_Array_.java} (78%) rename bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/{GIM_PAIR_Array.java => GIM_PAIR_Array_.java} (77%) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_ARRAY.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_ARRAY.java index 660e22940e0..d186f8f0b94 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_ARRAY.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_ARRAY.java @@ -14,7 +14,7 @@ @Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class GIM_BVH_DATA_ARRAY extends GIM_BVH_DATA_Array { +public class GIM_BVH_DATA_ARRAY extends GIM_BVH_DATA_Array_ { /** Empty constructor. Calls {@code super((Pointer)null)}. */ public GIM_BVH_DATA_ARRAY() { super((Pointer)null); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array_.java similarity index 77% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array_.java index 1fcfdd7f740..1751a440bd6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_DATA_Array_.java @@ -13,27 +13,27 @@ import static org.bytedeco.bullet.global.BulletCollision.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class GIM_BVH_DATA_Array extends Pointer { +public class GIM_BVH_DATA_Array_ extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public GIM_BVH_DATA_Array(Pointer p) { super(p); } + public GIM_BVH_DATA_Array_(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public GIM_BVH_DATA_Array(long size) { super((Pointer)null); allocateArray(size); } + public GIM_BVH_DATA_Array_(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public GIM_BVH_DATA_Array position(long position) { - return (GIM_BVH_DATA_Array)super.position(position); + @Override public GIM_BVH_DATA_Array_ position(long position) { + return (GIM_BVH_DATA_Array_)super.position(position); } - @Override public GIM_BVH_DATA_Array getPointer(long i) { - return new GIM_BVH_DATA_Array((Pointer)this).offsetAddress(i); + @Override public GIM_BVH_DATA_Array_ getPointer(long i) { + return new GIM_BVH_DATA_Array_((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") GIM_BVH_DATA_Array put(@Const @ByRef GIM_BVH_DATA_Array other); - public GIM_BVH_DATA_Array() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") GIM_BVH_DATA_Array_ put(@Const @ByRef GIM_BVH_DATA_Array_ other); + public GIM_BVH_DATA_Array_() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public GIM_BVH_DATA_Array(@Const @ByRef GIM_BVH_DATA_Array otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef GIM_BVH_DATA_Array otherArray); + public GIM_BVH_DATA_Array_(@Const @ByRef GIM_BVH_DATA_Array_ otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef GIM_BVH_DATA_Array_ otherArray); /** return the number of elements in the array */ public native int size(); @@ -84,5 +84,5 @@ public class GIM_BVH_DATA_Array extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef GIM_BVH_DATA_Array otherArray); + public native void copyFromArray(@Const @ByRef GIM_BVH_DATA_Array_ otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java index 2f3a5ce4777..7a13fe0196c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_ARRAY.java @@ -14,7 +14,7 @@ @Opaque @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class GIM_BVH_TREE_NODE_ARRAY extends GIM_BVH_TREE_NODE_Array { +public class GIM_BVH_TREE_NODE_ARRAY extends GIM_BVH_TREE_NODE_Array_ { /** Empty constructor. Calls {@code super((Pointer)null)}. */ public GIM_BVH_TREE_NODE_ARRAY() { super((Pointer)null); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array_.java similarity index 80% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array_.java index d4888fa9158..12a3dd1218f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_BVH_TREE_NODE_Array_.java @@ -13,27 +13,27 @@ import static org.bytedeco.bullet.global.BulletCollision.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class GIM_BVH_TREE_NODE_Array extends Pointer { +public class GIM_BVH_TREE_NODE_Array_ extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public GIM_BVH_TREE_NODE_Array(Pointer p) { super(p); } + public GIM_BVH_TREE_NODE_Array_(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public GIM_BVH_TREE_NODE_Array(long size) { super((Pointer)null); allocateArray(size); } + public GIM_BVH_TREE_NODE_Array_(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public GIM_BVH_TREE_NODE_Array position(long position) { - return (GIM_BVH_TREE_NODE_Array)super.position(position); + @Override public GIM_BVH_TREE_NODE_Array_ position(long position) { + return (GIM_BVH_TREE_NODE_Array_)super.position(position); } - @Override public GIM_BVH_TREE_NODE_Array getPointer(long i) { - return new GIM_BVH_TREE_NODE_Array((Pointer)this).offsetAddress(i); + @Override public GIM_BVH_TREE_NODE_Array_ getPointer(long i) { + return new GIM_BVH_TREE_NODE_Array_((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") GIM_BVH_TREE_NODE_Array put(@Const @ByRef GIM_BVH_TREE_NODE_Array other); - public GIM_BVH_TREE_NODE_Array() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") GIM_BVH_TREE_NODE_Array_ put(@Const @ByRef GIM_BVH_TREE_NODE_Array_ other); + public GIM_BVH_TREE_NODE_Array_() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public GIM_BVH_TREE_NODE_Array(@Const @ByRef GIM_BVH_TREE_NODE_Array otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef GIM_BVH_TREE_NODE_Array otherArray); + public GIM_BVH_TREE_NODE_Array_(@Const @ByRef GIM_BVH_TREE_NODE_Array_ otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef GIM_BVH_TREE_NODE_Array_ otherArray); /** return the number of elements in the array */ public native int size(); @@ -84,5 +84,5 @@ public class GIM_BVH_TREE_NODE_Array extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef GIM_BVH_TREE_NODE_Array otherArray); + public native void copyFromArray(@Const @ByRef GIM_BVH_TREE_NODE_Array_ otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array_.java similarity index 78% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array_.java index 4deb036ffc9..aab905df49c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_CONTACT_Array_.java @@ -13,27 +13,27 @@ import static org.bytedeco.bullet.global.BulletCollision.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class GIM_CONTACT_Array extends Pointer { +public class GIM_CONTACT_Array_ extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public GIM_CONTACT_Array(Pointer p) { super(p); } + public GIM_CONTACT_Array_(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public GIM_CONTACT_Array(long size) { super((Pointer)null); allocateArray(size); } + public GIM_CONTACT_Array_(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public GIM_CONTACT_Array position(long position) { - return (GIM_CONTACT_Array)super.position(position); + @Override public GIM_CONTACT_Array_ position(long position) { + return (GIM_CONTACT_Array_)super.position(position); } - @Override public GIM_CONTACT_Array getPointer(long i) { - return new GIM_CONTACT_Array((Pointer)this).offsetAddress(i); + @Override public GIM_CONTACT_Array_ getPointer(long i) { + return new GIM_CONTACT_Array_((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") GIM_CONTACT_Array put(@Const @ByRef GIM_CONTACT_Array other); - public GIM_CONTACT_Array() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") GIM_CONTACT_Array_ put(@Const @ByRef GIM_CONTACT_Array_ other); + public GIM_CONTACT_Array_() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public GIM_CONTACT_Array(@Const @ByRef GIM_CONTACT_Array otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef GIM_CONTACT_Array otherArray); + public GIM_CONTACT_Array_(@Const @ByRef GIM_CONTACT_Array_ otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef GIM_CONTACT_Array_ otherArray); /** return the number of elements in the array */ public native int size(); @@ -84,5 +84,5 @@ public class GIM_CONTACT_Array extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef GIM_CONTACT_Array otherArray); + public native void copyFromArray(@Const @ByRef GIM_CONTACT_Array_ otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array_.java similarity index 77% rename from bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array.java rename to bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array_.java index cd9aeef8b40..93fd8ce8f05 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/GIM_PAIR_Array_.java @@ -13,27 +13,27 @@ import static org.bytedeco.bullet.global.BulletCollision.*; @Name("btAlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class GIM_PAIR_Array extends Pointer { +public class GIM_PAIR_Array_ extends Pointer { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public GIM_PAIR_Array(Pointer p) { super(p); } + public GIM_PAIR_Array_(Pointer p) { super(p); } /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public GIM_PAIR_Array(long size) { super((Pointer)null); allocateArray(size); } + public GIM_PAIR_Array_(long size) { super((Pointer)null); allocateArray(size); } private native void allocateArray(long size); - @Override public GIM_PAIR_Array position(long position) { - return (GIM_PAIR_Array)super.position(position); + @Override public GIM_PAIR_Array_ position(long position) { + return (GIM_PAIR_Array_)super.position(position); } - @Override public GIM_PAIR_Array getPointer(long i) { - return new GIM_PAIR_Array((Pointer)this).offsetAddress(i); + @Override public GIM_PAIR_Array_ getPointer(long i) { + return new GIM_PAIR_Array_((Pointer)this).offsetAddress(i); } - public native @ByRef @Name("operator =") GIM_PAIR_Array put(@Const @ByRef GIM_PAIR_Array other); - public GIM_PAIR_Array() { super((Pointer)null); allocate(); } + public native @ByRef @Name("operator =") GIM_PAIR_Array_ put(@Const @ByRef GIM_PAIR_Array_ other); + public GIM_PAIR_Array_() { super((Pointer)null); allocate(); } private native void allocate(); /**Generally it is best to avoid using the copy constructor of an btAlignedObjectArray, and use a (const) reference to the array instead. */ - public GIM_PAIR_Array(@Const @ByRef GIM_PAIR_Array otherArray) { super((Pointer)null); allocate(otherArray); } - private native void allocate(@Const @ByRef GIM_PAIR_Array otherArray); + public GIM_PAIR_Array_(@Const @ByRef GIM_PAIR_Array_ otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef GIM_PAIR_Array_ otherArray); /** return the number of elements in the array */ public native int size(); @@ -84,5 +84,5 @@ public class GIM_PAIR_Array extends Pointer { //PCK: whole function public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); - public native void copyFromArray(@Const @ByRef GIM_PAIR_Array otherArray); + public native void copyFromArray(@Const @ByRef GIM_PAIR_Array_ otherArray); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContactArray.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContactArray.java index f642f098e5a..92fa18d073f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContactArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btContactArray.java @@ -14,7 +14,7 @@ @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btContactArray extends GIM_CONTACT_Array { +public class btContactArray extends GIM_CONTACT_Array_ { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btContactArray(Pointer p) { super(p); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairSet.java b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairSet.java index afb50e285de..a9a068ae4d7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairSet.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/BulletCollision/btPairSet.java @@ -15,7 +15,7 @@ /** A pairset array */ @Properties(inherit = org.bytedeco.bullet.presets.BulletCollision.class) -public class btPairSet extends GIM_PAIR_Array { +public class btPairSet extends GIM_PAIR_Array_ { static { Loader.load(); } /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public btPairSet(Pointer p) { super(p); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java index f16a1cc29a4..b0bdf8e431a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/BulletCollision.java @@ -58,16 +58,16 @@ public class BulletCollision extends org.bytedeco.bullet.presets.BulletCollision // Targeting ../BulletCollision/BT_QUANTIZED_BVH_NODE_Array.java -// Targeting ../BulletCollision/GIM_BVH_DATA_Array.java +// Targeting ../BulletCollision/GIM_BVH_DATA_Array_.java -// Targeting ../BulletCollision/GIM_BVH_TREE_NODE_Array.java +// Targeting ../BulletCollision/GIM_BVH_TREE_NODE_Array_.java -// Targeting ../BulletCollision/GIM_CONTACT_Array.java +// Targeting ../BulletCollision/GIM_CONTACT_Array_.java -// Targeting ../BulletCollision/GIM_PAIR_Array.java +// Targeting ../BulletCollision/GIM_PAIR_Array_.java // Targeting ../BulletCollision/btCell32ArrayArray.java From bd9dbeaa1f524e133ce4f1e055141e9be02ea33b Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 2 Mar 2022 00:05:57 +0800 Subject: [PATCH 61/81] Mappings for Bullet3Common library --- .../bullet/presets/Bullet3Common.java | 117 ++++++++++++++++++ bullet/src/main/java9/module-info.java | 1 + 2 files changed, 118 insertions(+) create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java new file mode 100644 index 00000000000..a815de6363e --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java @@ -0,0 +1,117 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +/** + * + * @author Andrey Krainyak + */ +@Properties( + inherit = javacpp.class, + value = { + @Platform( + include = { + "Bullet3Common/b3AlignedObjectArray.h", + "Bullet3Common/b3CommandLineArgs.h", + "Bullet3Common/b3FileUtils.h", + "Bullet3Common/b3HashMap.h", + "Bullet3Common/b3Logging.h", + "Bullet3Common/b3Scalar.h", + "Bullet3Common/b3Vector3.h", + "Bullet3Common/b3QuadWord.h", + "Bullet3Common/b3Quaternion.h", + "Bullet3Common/b3Matrix3x3.h", + "Bullet3Common/b3MinMax.h", + "Bullet3Common/b3ResizablePool.h", + "Bullet3Common/b3Transform.h", + "Bullet3Common/b3TransformUtil.h", + "Bullet3Common/shared/b3Float4.h", + "Bullet3Common/shared/b3Int2.h", + "Bullet3Common/shared/b3Int4.h", + "Bullet3Common/shared/b3Quat.h", + "Bullet3Common/shared/b3Mat3x3.h", + }, + link = "Bullet3Common@.3.20" + ) + }, + target = "org.bytedeco.bullet.Bullet3Common", + global = "org.bytedeco.bullet.global.Bullet3Common" +) +public class Bullet3Common implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + public void map(InfoMap infoMap) { + infoMap + .put(new Info("B3_ATTRIBUTE_ALIGNED16").cppText("#define B3_ATTRIBUTE_ALIGNED16(x) x")) + .put(new Info("B3_DECLARE_ALIGNED_ALLOCATOR").cppText("#define B3_DECLARE_ALIGNED_ALLOCATOR()")) + .put(new Info("B3_FORCE_INLINE").cppText("#define B3_FORCE_INLINE")) + .put(new Info("__global").cppText("#define __global")) + .put(new Info("__inline").cppText("#define __inline")) + + .put(new Info("B3_EPSILON").cppTypes("float")) + .put(new Info("B3_INFINITY").cppTypes("float")) + .put(new Info("B3_LARGE_FLOAT").cppTypes("float")) + + .put(new Info( + "b3Cross3", + "b3Dot3F4", + "b3Float4", + "b3Float4ConstArg", + "b3MakeFloat4", + "b3Mat3x3", + "b3Mat3x3ConstArg", + "b3Matrix3x3Data", + "b3Quat", + "b3QuatConstArg", + "b3TransformData", + "b3Vector3Data" + ).cppTypes().translate(false)) + + .put(new Info( + "(defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON)", + "B3_USE_DOUBLE_PRECISION", + "B3_USE_NEON", + "B3_USE_SSE", + "_WIN32", + "__clang__", + "defined B3_USE_SSE", + "defined(B3_USE_DOUBLE_PRECISION) || defined(B3_FORCE_DOUBLE_FUNCTIONS)", + "defined(B3_USE_DOUBLE_PRECISION)", + "defined(B3_USE_SSE) || defined(B3_USE_NEON)", + "defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)", + "defined(__SPU__) && defined(__CELLOS_LV2__)" + ).define(false)) + .put(new Info( + "__cplusplus" + ).define(true)) + ; + } +} diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 7a918a1e54b..7aeb1b3e5a2 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -6,4 +6,5 @@ exports org.bytedeco.bullet.BulletCollision; exports org.bytedeco.bullet.BulletDynamics; exports org.bytedeco.bullet.BulletSoftBody; + exports org.bytedeco.bullet.Bullet3Common; } From 249378e4e0434c5ed4857bda8a4a7d0bc9c717a5 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 3 Mar 2022 11:53:34 +0800 Subject: [PATCH 62/81] Update generated code for bullet's preset See parent commit. --- .../Bullet3Common/b3CommandLineArgs.java | 38 + .../b3ConvexSeparatingDistanceUtil.java | 30 + .../Bullet3Common/b3EnterProfileZoneFunc.java | 21 + .../Bullet3Common/b3ErrorMessageFunc.java | 21 + .../bullet/Bullet3Common/b3FileUtils.java | 69 + .../bullet/Bullet3Common/b3HashInt.java | 30 + .../bullet/Bullet3Common/b3HashPtr.java | 27 + .../bullet/Bullet3Common/b3HashString.java | 35 + .../bytedeco/bullet/Bullet3Common/b3Int2.java | 36 + .../bytedeco/bullet/Bullet3Common/b3Int4.java | 38 + .../Bullet3Common/b3LeaveProfileZoneFunc.java | 21 + .../bullet/Bullet3Common/b3Matrix3x3.java | 227 ++++ .../Bullet3Common/b3Matrix3x3DoubleData.java | 35 + .../Bullet3Common/b3Matrix3x3FloatData.java | 35 + .../bullet/Bullet3Common/b3PrintfFunc.java | 24 + .../bullet/Bullet3Common/b3ProfileZone.java | 25 + .../bullet/Bullet3Common/b3QuadWord.java | 119 ++ .../bullet/Bullet3Common/b3Quaternion.java | 168 +++ .../bullet/Bullet3Common/b3Transform.java | 147 +++ .../Bullet3Common/b3TransformDoubleData.java | 34 + .../Bullet3Common/b3TransformFloatData.java | 35 + .../bullet/Bullet3Common/b3TransformUtil.java | 46 + .../bullet/Bullet3Common/b3TypedObject.java | 25 + .../bullet/Bullet3Common/b3UnsignedInt2.java | 38 + .../bullet/Bullet3Common/b3UnsignedInt4.java | 38 + .../bullet/Bullet3Common/b3Vector3.java | 205 +++ .../Bullet3Common/b3Vector3DoubleData.java | 34 + .../Bullet3Common/b3Vector3FloatData.java | 34 + .../bullet/Bullet3Common/b3Vector4.java | 62 + .../Bullet3Common/b3WarningMessageFunc.java | 21 + .../bytedeco/bullet/global/Bullet3Common.java | 1154 +++++++++++++++++ 31 files changed, 2872 insertions(+) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3CommandLineArgs.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ConvexSeparatingDistanceUtil.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3EnterProfileZoneFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ErrorMessageFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3FileUtils.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashInt.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashPtr.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashString.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3LeaveProfileZoneFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3DoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3FloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3PrintfFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ProfileZone.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3QuadWord.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Quaternion.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Transform.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformUtil.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TypedObject.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedInt2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedInt4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3DoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3FloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3WarningMessageFunc.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3CommandLineArgs.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3CommandLineArgs.java new file mode 100644 index 00000000000..2ee9a524c44 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3CommandLineArgs.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3CommandLineArgs extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CommandLineArgs(Pointer p) { super(p); } + + // Constructor + public b3CommandLineArgs(int argc, @Cast("char**") PointerPointer argv) { super((Pointer)null); allocate(argc, argv); } + private native void allocate(int argc, @Cast("char**") PointerPointer argv); + public b3CommandLineArgs(int argc, @Cast("char**") @ByPtrPtr BytePointer argv) { super((Pointer)null); allocate(argc, argv); } + private native void allocate(int argc, @Cast("char**") @ByPtrPtr BytePointer argv); + public b3CommandLineArgs(int argc, @Cast("char**") @ByPtrPtr ByteBuffer argv) { super((Pointer)null); allocate(argc, argv); } + private native void allocate(int argc, @Cast("char**") @ByPtrPtr ByteBuffer argv); + public b3CommandLineArgs(int argc, @Cast("char**") @ByPtrPtr byte[] argv) { super((Pointer)null); allocate(argc, argv); } + private native void allocate(int argc, @Cast("char**") @ByPtrPtr byte[] argv); + + public native void addArgs(int argc, @Cast("char**") PointerPointer argv); + public native void addArgs(int argc, @Cast("char**") @ByPtrPtr BytePointer argv); + public native void addArgs(int argc, @Cast("char**") @ByPtrPtr ByteBuffer argv); + public native void addArgs(int argc, @Cast("char**") @ByPtrPtr byte[] argv); + + public native @Cast("bool") boolean CheckCmdLineFlag(@Cast("const char*") BytePointer arg_name); + public native @Cast("bool") boolean CheckCmdLineFlag(String arg_name); + + public native int ParsedArgc(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ConvexSeparatingDistanceUtil.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ConvexSeparatingDistanceUtil.java new file mode 100644 index 00000000000..3eb618fea54 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ConvexSeparatingDistanceUtil.java @@ -0,0 +1,30 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +/**The b3ConvexSeparatingDistanceUtil can help speed up convex collision detection + * by conservatively updating a cached separating distance/vector instead of re-calculating the closest distance */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3ConvexSeparatingDistanceUtil extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConvexSeparatingDistanceUtil(Pointer p) { super(p); } + + public b3ConvexSeparatingDistanceUtil(@Cast("b3Scalar") float boundingRadiusA, @Cast("b3Scalar") float boundingRadiusB) { super((Pointer)null); allocate(boundingRadiusA, boundingRadiusB); } + private native void allocate(@Cast("b3Scalar") float boundingRadiusA, @Cast("b3Scalar") float boundingRadiusB); + + public native @Cast("b3Scalar") float getConservativeSeparatingDistance(); + + public native void updateSeparatingDistance(@Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB); + + public native void initSeparatingDistance(@Const @ByRef b3Vector3 separatingVector, @Cast("b3Scalar") float separatingDistance, @Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3EnterProfileZoneFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3EnterProfileZoneFunc.java new file mode 100644 index 00000000000..a2502ee9876 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3EnterProfileZoneFunc.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3EnterProfileZoneFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3EnterProfileZoneFunc(Pointer p) { super(p); } + protected b3EnterProfileZoneFunc() { allocate(); } + private native void allocate(); + public native void call(@Cast("const char*") BytePointer msg); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ErrorMessageFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ErrorMessageFunc.java new file mode 100644 index 00000000000..e950028c4c6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ErrorMessageFunc.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3ErrorMessageFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ErrorMessageFunc(Pointer p) { super(p); } + protected b3ErrorMessageFunc() { allocate(); } + private native void allocate(); + public native void call(@Cast("const char*") BytePointer msg); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3FileUtils.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3FileUtils.java new file mode 100644 index 00000000000..672b528dcae --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3FileUtils.java @@ -0,0 +1,69 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3FileUtils extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3FileUtils(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3FileUtils(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3FileUtils position(long position) { + return (b3FileUtils)super.position(position); + } + @Override public b3FileUtils getPointer(long i) { + return new b3FileUtils((Pointer)this).offsetAddress(i); + } + + public b3FileUtils() { super((Pointer)null); allocate(); } + private native void allocate(); + + public static native @Cast("bool") boolean findFile(@Cast("const char*") BytePointer orgFileName, @Cast("char*") BytePointer relativeFileName, int maxRelativeFileNameMaxLen); + public static native @Cast("bool") boolean findFile(String orgFileName, @Cast("char*") ByteBuffer relativeFileName, int maxRelativeFileNameMaxLen); + public static native @Cast("bool") boolean findFile(@Cast("const char*") BytePointer orgFileName, @Cast("char*") byte[] relativeFileName, int maxRelativeFileNameMaxLen); + public static native @Cast("bool") boolean findFile(String orgFileName, @Cast("char*") BytePointer relativeFileName, int maxRelativeFileNameMaxLen); + public static native @Cast("bool") boolean findFile(@Cast("const char*") BytePointer orgFileName, @Cast("char*") ByteBuffer relativeFileName, int maxRelativeFileNameMaxLen); + public static native @Cast("bool") boolean findFile(String orgFileName, @Cast("char*") byte[] relativeFileName, int maxRelativeFileNameMaxLen); + + public static native @Cast("const char*") BytePointer strip2(@Cast("const char*") BytePointer name, @Cast("const char*") BytePointer pattern); + public static native String strip2(String name, String pattern); + + public static native int extractPath(@Cast("const char*") BytePointer fileName, @Cast("char*") BytePointer path, int maxPathLength); + public static native int extractPath(String fileName, @Cast("char*") ByteBuffer path, int maxPathLength); + public static native int extractPath(@Cast("const char*") BytePointer fileName, @Cast("char*") byte[] path, int maxPathLength); + public static native int extractPath(String fileName, @Cast("char*") BytePointer path, int maxPathLength); + public static native int extractPath(@Cast("const char*") BytePointer fileName, @Cast("char*") ByteBuffer path, int maxPathLength); + public static native int extractPath(String fileName, @Cast("char*") byte[] path, int maxPathLength); + + public static native @Cast("char") byte toLowerChar(@Cast("const char") byte t); + + public static native void toLower(@Cast("char*") BytePointer str); + public static native void toLower(@Cast("char*") ByteBuffer str); + public static native void toLower(@Cast("char*") byte[] str); + + /*static const char* strip2(const char* name, const char* pattern) + { + size_t const patlen = strlen(pattern); + size_t patcnt = 0; + const char * oriptr; + const char * patloc; + // find how many times the pattern occurs in the original string + for (oriptr = name; patloc = strstr(oriptr, pattern); oriptr = patloc + patlen) + { + patcnt++; + } + return oriptr; + } + */ +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashInt.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashInt.java new file mode 100644 index 00000000000..c9e3ad3eb87 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashInt.java @@ -0,0 +1,30 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3HashInt extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3HashInt(Pointer p) { super(p); } + + public b3HashInt(int uid) { super((Pointer)null); allocate(uid); } + private native void allocate(int uid); + + public native int getUid1(); + + public native void setUid1(int uid); + + public native @Cast("bool") boolean equals(@Const @ByRef b3HashInt other); + //to our success + public native @Cast("unsigned int") int getHash(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashPtr.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashPtr.java new file mode 100644 index 00000000000..3a7fe693cf5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashPtr.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3HashPtr extends Pointer { + static { Loader.load(); } + + public b3HashPtr(@Const Pointer ptr) { super((Pointer)null); allocate(ptr); } + private native void allocate(@Const Pointer ptr); + + public native @Const Pointer getPointer(); + + public native @Cast("bool") boolean equals(@Const @ByRef b3HashPtr other); + + //to our success + public native @Cast("unsigned int") int getHash(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashString.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashString.java new file mode 100644 index 00000000000..334bfe789ee --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3HashString.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +/**very basic hashable string implementation, compatible with b3HashMap */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3HashString extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3HashString(Pointer p) { super(p); } + + public native @StdString BytePointer m_string(); public native b3HashString m_string(BytePointer setter); + public native @Cast("unsigned int") int m_hash(); public native b3HashString m_hash(int setter); + + public native @Cast("unsigned int") int getHash(); + + public b3HashString(@Cast("const char*") BytePointer name) { super((Pointer)null); allocate(name); } + private native void allocate(@Cast("const char*") BytePointer name); + public b3HashString(String name) { super((Pointer)null); allocate(name); } + private native void allocate(String name); + + public native int portableStringCompare(@Cast("const char*") BytePointer src, @Cast("const char*") BytePointer dst); + public native int portableStringCompare(String src, String dst); + + public native @Cast("bool") boolean equals(@Const @ByRef b3HashString other); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int2.java new file mode 100644 index 00000000000..9dd3c643c06 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int2.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Int2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Int2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Int2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Int2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Int2 position(long position) { + return (b3Int2)super.position(position); + } + @Override public b3Int2 getPointer(long i) { + return new b3Int2((Pointer)this).offsetAddress(i); + } + + public native int x(); public native b3Int2 x(int setter); + public native int y(); public native b3Int2 y(int setter); + public native int s(int i); public native b3Int2 s(int i, int setter); + @MemberGetter public native IntPointer s(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int4.java new file mode 100644 index 00000000000..17eeeac5023 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int4.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Int4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Int4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Int4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Int4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Int4 position(long position) { + return (b3Int4)super.position(position); + } + @Override public b3Int4 getPointer(long i) { + return new b3Int4((Pointer)this).offsetAddress(i); + } + + public native int x(); public native b3Int4 x(int setter); + public native int y(); public native b3Int4 y(int setter); + public native int z(); public native b3Int4 z(int setter); + public native int w(); public native b3Int4 w(int setter); + public native int s(int i); public native b3Int4 s(int i, int setter); + @MemberGetter public native IntPointer s(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3LeaveProfileZoneFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3LeaveProfileZoneFunc.java new file mode 100644 index 00000000000..d2487c354f5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3LeaveProfileZoneFunc.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3LeaveProfileZoneFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3LeaveProfileZoneFunc(Pointer p) { super(p); } + protected b3LeaveProfileZoneFunc() { allocate(); } + private native void allocate(); + public native void call(); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3.java new file mode 100644 index 00000000000..1365c8063fc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3.java @@ -0,0 +1,227 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +// #endif //B3_USE_DOUBLE_PRECISION + +/**\brief The b3Matrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with b3Quaternion, b3Transform and b3Vector3. +* Make sure to only include a pure orthogonal matrix without scaling. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Matrix3x3 extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Matrix3x3(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Matrix3x3(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Matrix3x3 position(long position) { + return (b3Matrix3x3)super.position(position); + } + @Override public b3Matrix3x3 getPointer(long i) { + return new b3Matrix3x3((Pointer)this).offsetAddress(i); + } + + /** \brief No initializaion constructor */ + public b3Matrix3x3() { super((Pointer)null); allocate(); } + private native void allocate(); + + // explicit b3Matrix3x3(const b3Scalar *m) { setFromOpenGLSubMatrix(m); } + + /**\brief Constructor from Quaternion */ + public b3Matrix3x3(@Const @ByRef b3Quaternion q) { super((Pointer)null); allocate(q); } + private native void allocate(@Const @ByRef b3Quaternion q); + /* + template + Matrix3x3(const b3Scalar& yaw, const b3Scalar& pitch, const b3Scalar& roll) + { + setEulerYPR(yaw, pitch, roll); + } + */ + /** \brief Constructor with row major formatting */ + public b3Matrix3x3(@Cast("const b3Scalar") float xx, @Cast("const b3Scalar") float xy, @Cast("const b3Scalar") float xz, + @Cast("const b3Scalar") float yx, @Cast("const b3Scalar") float yy, @Cast("const b3Scalar") float yz, + @Cast("const b3Scalar") float zx, @Cast("const b3Scalar") float zy, @Cast("const b3Scalar") float zz) { super((Pointer)null); allocate(xx, xy, xz, yx, yy, yz, zx, zy, zz); } + private native void allocate(@Cast("const b3Scalar") float xx, @Cast("const b3Scalar") float xy, @Cast("const b3Scalar") float xz, + @Cast("const b3Scalar") float yx, @Cast("const b3Scalar") float yy, @Cast("const b3Scalar") float yz, + @Cast("const b3Scalar") float zx, @Cast("const b3Scalar") float zy, @Cast("const b3Scalar") float zz); + +// #if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON) + +// #else + + /** \brief Copy constructor */ + public b3Matrix3x3(@Const @ByRef b3Matrix3x3 other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef b3Matrix3x3 other); + + /** \brief Assignment Operator */ + public native @ByRef @Name("operator =") b3Matrix3x3 put(@Const @ByRef b3Matrix3x3 other); + +// #endif + + /** \brief Get a column of the matrix as a vector + * @param i Column number 0 indexed */ + public native @ByVal b3Vector3 getColumn(int i); + + /** \brief Get a row of the matrix as a vector + * @param i Row number 0 indexed */ + public native @Const @ByRef b3Vector3 getRow(int i); + + /** \brief Get a mutable reference to a row of the matrix as a vector + * @param i Row number 0 indexed */ + public native @ByRef @Name("operator []") b3Vector3 get(int i); + + /** \brief Get a const reference to a row of the matrix as a vector + * @param i Row number 0 indexed */ + + /** \brief Multiply by the target matrix on the right + * @param m Rotation matrix to be applied + * Equivilant to this = this * m */ + public native @ByRef @Name("operator *=") b3Matrix3x3 multiplyPut(@Const @ByRef b3Matrix3x3 m); + + /** \brief Adds by the target matrix on the right + * @param m matrix to be applied + * Equivilant to this = this + m */ + public native @ByRef @Name("operator +=") b3Matrix3x3 addPut(@Const @ByRef b3Matrix3x3 m); + + /** \brief Substractss by the target matrix on the right + * @param m matrix to be applied + * Equivilant to this = this - m */ + public native @ByRef @Name("operator -=") b3Matrix3x3 subtractPut(@Const @ByRef b3Matrix3x3 m); + + /** \brief Set from the rotational part of a 4x4 OpenGL matrix + * @param m A pointer to the beginning of the array of scalars*/ + public native void setFromOpenGLSubMatrix(@Cast("const b3Scalar*") FloatPointer m); + public native void setFromOpenGLSubMatrix(@Cast("const b3Scalar*") FloatBuffer m); + public native void setFromOpenGLSubMatrix(@Cast("const b3Scalar*") float[] m); + /** \brief Set the values of the matrix explicitly (row major) + * @param xx Top left + * @param xy Top Middle + * @param xz Top Right + * @param yx Middle Left + * @param yy Middle Middle + * @param yz Middle Right + * @param zx Bottom Left + * @param zy Bottom Middle + * @param zz Bottom Right*/ + public native void setValue(@Cast("const b3Scalar") float xx, @Cast("const b3Scalar") float xy, @Cast("const b3Scalar") float xz, + @Cast("const b3Scalar") float yx, @Cast("const b3Scalar") float yy, @Cast("const b3Scalar") float yz, + @Cast("const b3Scalar") float zx, @Cast("const b3Scalar") float zy, @Cast("const b3Scalar") float zz); + + /** \brief Set the matrix from a quaternion + * @param q The Quaternion to match */ + public native void setRotation(@Const @ByRef b3Quaternion q); + + /** \brief Set the matrix from euler angles using YPR around YXZ respectively + * @param yaw Yaw about Y axis + * @param pitch Pitch about X axis + * @param roll Roll about Z axis + */ + public native void setEulerYPR(@Cast("const b3Scalar") float yaw, @Cast("const b3Scalar") float pitch, @Cast("const b3Scalar") float roll); + + /** \brief Set the matrix from euler angles YPR around ZYX axes + * @param eulerX Roll about X axis + * @param eulerY Pitch around Y axis + * @param eulerZ Yaw aboud Z axis + * + * These angles are used to produce a rotation matrix. The euler + * angles are applied in ZYX order. I.e a vector is first rotated + * about X then Y and then Z + **/ + public native void setEulerZYX(@Cast("b3Scalar") float eulerX, @Cast("b3Scalar") float eulerY, @Cast("b3Scalar") float eulerZ); + + /**\brief Set the matrix to the identity */ + public native void setIdentity(); + + public static native @Const @ByRef b3Matrix3x3 getIdentity(); + + /**\brief Fill the rotational part of an OpenGL matrix and clear the shear/perspective + * @param m The array to be filled */ + public native void getOpenGLSubMatrix(@Cast("b3Scalar*") FloatPointer m); + public native void getOpenGLSubMatrix(@Cast("b3Scalar*") FloatBuffer m); + public native void getOpenGLSubMatrix(@Cast("b3Scalar*") float[] m); + + /**\brief Get the matrix represented as a quaternion + * @param q The quaternion which will be set */ + public native void getRotation(@ByRef b3Quaternion q); + + /**\brief Get the matrix represented as euler angles around YXZ, roundtrip with setEulerYPR + * @param yaw Yaw around Y axis + * @param pitch Pitch around X axis + * @param roll around Z axis */ + public native void getEulerYPR(@Cast("b3Scalar*") @ByRef FloatPointer yaw, @Cast("b3Scalar*") @ByRef FloatPointer pitch, @Cast("b3Scalar*") @ByRef FloatPointer roll); + public native void getEulerYPR(@Cast("b3Scalar*") @ByRef FloatBuffer yaw, @Cast("b3Scalar*") @ByRef FloatBuffer pitch, @Cast("b3Scalar*") @ByRef FloatBuffer roll); + public native void getEulerYPR(@Cast("b3Scalar*") @ByRef float[] yaw, @Cast("b3Scalar*") @ByRef float[] pitch, @Cast("b3Scalar*") @ByRef float[] roll); + + /**\brief Get the matrix represented as euler angles around ZYX + * @param yaw Yaw around X axis + * @param pitch Pitch around Y axis + * @param roll around X axis + * @param solution_number Which solution of two possible solutions ( 1 or 2) are possible values*/ + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef FloatPointer yaw, @Cast("b3Scalar*") @ByRef FloatPointer pitch, @Cast("b3Scalar*") @ByRef FloatPointer roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef FloatPointer yaw, @Cast("b3Scalar*") @ByRef FloatPointer pitch, @Cast("b3Scalar*") @ByRef FloatPointer roll); + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef FloatBuffer yaw, @Cast("b3Scalar*") @ByRef FloatBuffer pitch, @Cast("b3Scalar*") @ByRef FloatBuffer roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef FloatBuffer yaw, @Cast("b3Scalar*") @ByRef FloatBuffer pitch, @Cast("b3Scalar*") @ByRef FloatBuffer roll); + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef float[] yaw, @Cast("b3Scalar*") @ByRef float[] pitch, @Cast("b3Scalar*") @ByRef float[] roll, @Cast("unsigned int") int solution_number/*=1*/); + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef float[] yaw, @Cast("b3Scalar*") @ByRef float[] pitch, @Cast("b3Scalar*") @ByRef float[] roll); + + /**\brief Create a scaled copy of the matrix + * @param s Scaling vector The elements of the vector will scale each column */ + + public native @ByVal b3Matrix3x3 scaled(@Const @ByRef b3Vector3 s); + + /**\brief Return the determinant of the matrix */ + public native @Cast("b3Scalar") float determinant(); + /**\brief Return the adjoint of the matrix */ + public native @ByVal b3Matrix3x3 adjoint(); + /**\brief Return the matrix with all values non negative */ + public native @ByVal b3Matrix3x3 absolute(); + /**\brief Return the transpose of the matrix */ + public native @ByVal b3Matrix3x3 transpose(); + /**\brief Return the inverse of the matrix */ + public native @ByVal b3Matrix3x3 inverse(); + + public native @ByVal b3Matrix3x3 transposeTimes(@Const @ByRef b3Matrix3x3 m); + public native @ByVal b3Matrix3x3 timesTranspose(@Const @ByRef b3Matrix3x3 m); + + public native @Cast("b3Scalar") float tdotx(@Const @ByRef b3Vector3 v); + public native @Cast("b3Scalar") float tdoty(@Const @ByRef b3Vector3 v); + public native @Cast("b3Scalar") float tdotz(@Const @ByRef b3Vector3 v); + + /**\brief diagonalizes this matrix by the Jacobi method. + * @param rot stores the rotation from the coordinate system in which the matrix is diagonal to the original + * coordinate system, i.e., old_this = rot * new_this * rot^T. + * @param threshold See iteration + * @param iteration The iteration stops when all off-diagonal elements are less than the threshold multiplied + * by the sum of the absolute values of the diagonal, or when maxSteps have been executed. + * + * Note that this matrix is assumed to be symmetric. + */ + public native void diagonalize(@ByRef b3Matrix3x3 rot, @Cast("b3Scalar") float threshold, int maxSteps); + + /**\brief Calculate the matrix cofactor + * @param r1 The first row to use for calculating the cofactor + * @param c1 The first column to use for calculating the cofactor + * @param r1 The second row to use for calculating the cofactor + * @param c1 The second column to use for calculating the cofactor + * See http://en.wikipedia.org/wiki/Cofactor_(linear_algebra) for more details + */ + public native @Cast("b3Scalar") float cofac(int r1, int c1, int r2, int c2); + + public native void serialize(@ByRef b3Matrix3x3FloatData dataOut); + + public native void serializeFloat(@ByRef b3Matrix3x3FloatData dataOut); + + public native void deSerialize(@Const @ByRef b3Matrix3x3FloatData dataIn); + + public native void deSerializeFloat(@Const @ByRef b3Matrix3x3FloatData dataIn); + + public native void deSerializeDouble(@Const @ByRef b3Matrix3x3DoubleData dataIn); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3DoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3DoubleData.java new file mode 100644 index 00000000000..d1541f3b2ec --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3DoubleData.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +/**for serialization */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Matrix3x3DoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Matrix3x3DoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Matrix3x3DoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Matrix3x3DoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Matrix3x3DoubleData position(long position) { + return (b3Matrix3x3DoubleData)super.position(position); + } + @Override public b3Matrix3x3DoubleData getPointer(long i) { + return new b3Matrix3x3DoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3DoubleData m_el(int i); public native b3Matrix3x3DoubleData m_el(int i, b3Vector3DoubleData setter); + @MemberGetter public native b3Vector3DoubleData m_el(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3FloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3FloatData.java new file mode 100644 index 00000000000..bd42dc8afa8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Matrix3x3FloatData.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +/**for serialization */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Matrix3x3FloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Matrix3x3FloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Matrix3x3FloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Matrix3x3FloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Matrix3x3FloatData position(long position) { + return (b3Matrix3x3FloatData)super.position(position); + } + @Override public b3Matrix3x3FloatData getPointer(long i) { + return new b3Matrix3x3FloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3FloatData m_el(int i); public native b3Matrix3x3FloatData m_el(int i, b3Vector3FloatData setter); + @MemberGetter public native b3Vector3FloatData m_el(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3PrintfFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3PrintfFunc.java new file mode 100644 index 00000000000..71e6aa5e3b4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3PrintfFunc.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +// #endif //#ifndef B3_NO_PROFILE + + @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3PrintfFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3PrintfFunc(Pointer p) { super(p); } + protected b3PrintfFunc() { allocate(); } + private native void allocate(); + public native void call(@Cast("const char*") BytePointer msg); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ProfileZone.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ProfileZone.java new file mode 100644 index 00000000000..b899b8371cd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3ProfileZone.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +// #ifdef __cplusplus + + @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3ProfileZone extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ProfileZone(Pointer p) { super(p); } + + public b3ProfileZone(@Cast("const char*") BytePointer name) { super((Pointer)null); allocate(name); } + private native void allocate(@Cast("const char*") BytePointer name); + public b3ProfileZone(String name) { super((Pointer)null); allocate(name); } + private native void allocate(String name); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3QuadWord.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3QuadWord.java new file mode 100644 index 00000000000..e305b92a68a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3QuadWord.java @@ -0,0 +1,119 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +// #endif + +/**\brief The b3QuadWord class is base class for b3Vector3 and b3Quaternion. + * Some issues under PS3 Linux with IBM 2.1 SDK, gcc compiler prevent from using aligned quadword. + */ +// #ifndef USE_LIBSPE2 +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3QuadWord extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3QuadWord(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3QuadWord(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3QuadWord position(long position) { + return (b3QuadWord)super.position(position); + } + @Override public b3QuadWord getPointer(long i) { + return new b3QuadWord((Pointer)this).offsetAddress(i); + } + + public native @Cast("b3Scalar") float m_floats(int i); public native b3QuadWord m_floats(int i, float setter); + @MemberGetter public native @Cast("b3Scalar*") FloatPointer m_floats(); + public native @Cast("b3Scalar") float x(); public native b3QuadWord x(float setter); + public native @Cast("b3Scalar") float y(); public native b3QuadWord y(float setter); + public native @Cast("b3Scalar") float z(); public native b3QuadWord z(float setter); + public native @Cast("b3Scalar") float w(); public native b3QuadWord w(float setter); +// #if defined(B3_USE_SSE) || defined(B3_USE_NEON) + +// #endif + + /**\brief Return the x value */ + public native @Cast("const b3Scalar") float getX(); + /**\brief Return the y value */ + public native @Cast("const b3Scalar") float getY(); + /**\brief Return the z value */ + public native @Cast("const b3Scalar") float getZ(); + /**\brief Set the x value */ + public native void setX(@Cast("b3Scalar") float _x); + /**\brief Set the y value */ + public native void setY(@Cast("b3Scalar") float _y); + /**\brief Set the z value */ + public native void setZ(@Cast("b3Scalar") float _z); + /**\brief Set the w value */ + public native void setW(@Cast("b3Scalar") float _w); + /**\brief Return the x value */ + + //B3_FORCE_INLINE b3Scalar& operator[](int i) { return (&m_floats[0])[i]; } + //B3_FORCE_INLINE const b3Scalar& operator[](int i) const { return (&m_floats[0])[i]; } + /**operator b3Scalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. */ + public native @Cast("b3Scalar*") @Name("operator b3Scalar*") FloatPointer asFloatPointer(); + + public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef b3QuadWord other); + + public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef b3QuadWord other); + + /**\brief Set x,y,z and zero w + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + public native void setValue(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z); + + /* void getValue(b3Scalar *m) const + { + m[0] = m_floats[0]; + m[1] = m_floats[1]; + m[2] = m_floats[2]; + } +*/ + /**\brief Set the values + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public native void setValue(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z, @Cast("const b3Scalar") float _w); + /**\brief No initialization constructor */ + public b3QuadWord() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**\brief Three argument constructor (zeros w) + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + public b3QuadWord(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z) { super((Pointer)null); allocate(_x, _y, _z); } + private native void allocate(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z); + + /**\brief Initializing constructor + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public b3QuadWord(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z, @Cast("const b3Scalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z, @Cast("const b3Scalar") float _w); + + /**\brief Set each element to the max of the current values and the values of another b3QuadWord + * @param other The other b3QuadWord to compare with + */ + public native void setMax(@Const @ByRef b3QuadWord other); + /**\brief Set each element to the min of the current values and the values of another b3QuadWord + * @param other The other b3QuadWord to compare with + */ + public native void setMin(@Const @ByRef b3QuadWord other); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Quaternion.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Quaternion.java new file mode 100644 index 00000000000..56b1ffd0683 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Quaternion.java @@ -0,0 +1,168 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +// #ifdef B3_USE_SSE + +// #endif + +// #if defined(B3_USE_SSE) || defined(B3_USE_NEON) + +// #endif + +/**\brief The b3Quaternion implements quaternion to perform linear algebra rotations in combination with b3Matrix3x3, b3Vector3 and b3Transform. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Quaternion extends b3QuadWord { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Quaternion(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Quaternion(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Quaternion position(long position) { + return (b3Quaternion)super.position(position); + } + @Override public b3Quaternion getPointer(long i) { + return new b3Quaternion((Pointer)this).offsetAddress(i); + } + + /**\brief No initialization constructor */ + public b3Quaternion() { super((Pointer)null); allocate(); } + private native void allocate(); + +// #if (defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)) || defined(B3_USE_NEON) + +// #endif + + // template + // explicit Quaternion(const b3Scalar *v) : Tuple4(v) {} + /**\brief Constructor from scalars */ + public b3Quaternion(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z, @Cast("const b3Scalar") float _w) { super((Pointer)null); allocate(_x, _y, _z, _w); } + private native void allocate(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z, @Cast("const b3Scalar") float _w); + /**\brief Axis angle Constructor + * @param axis The axis which the rotation is around + * @param angle The magnitude of the rotation around the angle (Radians) */ + public b3Quaternion(@Const @ByRef b3Vector3 _axis, @Cast("const b3Scalar") float _angle) { super((Pointer)null); allocate(_axis, _angle); } + private native void allocate(@Const @ByRef b3Vector3 _axis, @Cast("const b3Scalar") float _angle); + /**\brief Constructor from Euler angles + * @param yaw Angle around Y unless B3_EULER_DEFAULT_ZYX defined then Z + * @param pitch Angle around X unless B3_EULER_DEFAULT_ZYX defined then Y + * @param roll Angle around Z unless B3_EULER_DEFAULT_ZYX defined then X */ + public b3Quaternion(@Cast("const b3Scalar") float yaw, @Cast("const b3Scalar") float pitch, @Cast("const b3Scalar") float roll) { super((Pointer)null); allocate(yaw, pitch, roll); } + private native void allocate(@Cast("const b3Scalar") float yaw, @Cast("const b3Scalar") float pitch, @Cast("const b3Scalar") float roll); + /**\brief Set the rotation using axis angle notation + * @param axis The axis around which to rotate + * @param angle The magnitude of the rotation in Radians */ + public native void setRotation(@Const @ByRef b3Vector3 axis1, @Cast("const b3Scalar") float _angle); + /**\brief Set the quaternion using Euler angles + * @param yaw Angle around Y + * @param pitch Angle around X + * @param roll Angle around Z */ + public native void setEuler(@Cast("const b3Scalar") float yaw, @Cast("const b3Scalar") float pitch, @Cast("const b3Scalar") float roll); + + /**\brief Set the quaternion using euler angles + * @param yaw Angle around Z + * @param pitch Angle around Y + * @param roll Angle around X */ + public native void setEulerZYX(@Cast("const b3Scalar") float yawZ, @Cast("const b3Scalar") float pitchY, @Cast("const b3Scalar") float rollX); + + /**\brief Get the euler angles from this quaternion + * @param yaw Angle around Z + * @param pitch Angle around Y + * @param roll Angle around X */ + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef FloatPointer yawZ, @Cast("b3Scalar*") @ByRef FloatPointer pitchY, @Cast("b3Scalar*") @ByRef FloatPointer rollX); + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef FloatBuffer yawZ, @Cast("b3Scalar*") @ByRef FloatBuffer pitchY, @Cast("b3Scalar*") @ByRef FloatBuffer rollX); + public native void getEulerZYX(@Cast("b3Scalar*") @ByRef float[] yawZ, @Cast("b3Scalar*") @ByRef float[] pitchY, @Cast("b3Scalar*") @ByRef float[] rollX); + + /**\brief Add two quaternions + * @param q The quaternion to add to this one */ + public native @ByRef @Name("operator +=") b3Quaternion addPut(@Const @ByRef b3Quaternion q); + + /**\brief Subtract out a quaternion + * @param q The quaternion to subtract from this one */ + public native @ByRef @Name("operator -=") b3Quaternion subtractPut(@Const @ByRef b3Quaternion q); + + /**\brief Scale this quaternion + * @param s The scalar to scale by */ + public native @ByRef @Name("operator *=") b3Quaternion multiplyPut(@Cast("const b3Scalar") float s); + + /**\brief Multiply this quaternion by q on the right + * @param q The other quaternion + * Equivilant to this = this * q */ + public native @ByRef @Name("operator *=") b3Quaternion multiplyPut(@Const @ByRef b3Quaternion q); + /**\brief Return the dot product between this quaternion and another + * @param q The other quaternion */ + public native @Cast("b3Scalar") float dot(@Const @ByRef b3Quaternion q); + + /**\brief Return the length squared of the quaternion */ + public native @Cast("b3Scalar") float length2(); + + /**\brief Return the length of the quaternion */ + public native @Cast("b3Scalar") float length(); + + /**\brief Normalize the quaternion + * Such that x^2 + y^2 + z^2 +w^2 = 1 */ + public native @ByRef b3Quaternion normalize(); + + /**\brief Return a scaled version of this quaternion + * @param s The scale factor */ + public native @ByVal @Name("operator *") b3Quaternion multiply(@Cast("const b3Scalar") float s); + + /**\brief Return an inversely scaled versionof this quaternion + * @param s The inverse scale factor */ + public native @ByVal @Name("operator /") b3Quaternion divide(@Cast("const b3Scalar") float s); + + /**\brief Inversely scale this quaternion + * @param s The scale factor */ + public native @ByRef @Name("operator /=") b3Quaternion dividePut(@Cast("const b3Scalar") float s); + + /**\brief Return a normalized version of this quaternion */ + public native @ByVal b3Quaternion normalized(); + /**\brief Return the angle between this quaternion and the other + * @param q The other quaternion */ + public native @Cast("b3Scalar") float angle(@Const @ByRef b3Quaternion q); + /**\brief Return the angle of rotation represented by this quaternion */ + public native @Cast("b3Scalar") float getAngle(); + + /**\brief Return the axis of the rotation represented by this quaternion */ + public native @ByVal b3Vector3 getAxis(); + + /**\brief Return the inverse of this quaternion */ + public native @ByVal b3Quaternion inverse(); + + /**\brief Return the sum of this quaternion and the other + * @param q2 The other quaternion */ + public native @ByVal @Name("operator +") b3Quaternion add(@Const @ByRef b3Quaternion q2); + + /**\brief Return the difference between this quaternion and the other + * @param q2 The other quaternion */ + public native @ByVal @Name("operator -") b3Quaternion subtract(@Const @ByRef b3Quaternion q2); + + /**\brief Return the negative of this quaternion + * This simply negates each element */ + public native @ByVal @Name("operator -") b3Quaternion subtract(); + /**\todo document this and it's use */ + public native @ByVal b3Quaternion farthest(@Const @ByRef b3Quaternion qd); + + /**\todo document this and it's use */ + public native @ByVal b3Quaternion nearest(@Const @ByRef b3Quaternion qd); + + /**\brief Return the quaternion which is the result of Spherical Linear Interpolation between this and the other quaternion + * @param q The other quaternion to interpolate with + * @param t The ratio between this and q to interpolate. If t = 0 the result is this, if t=1 the result is q. + * Slerp interpolates assuming constant velocity. */ + public native @ByVal b3Quaternion slerp(@Const @ByRef b3Quaternion q, @Cast("const b3Scalar") float t); + + public static native @Const @ByRef b3Quaternion getIdentity(); + + public native @Cast("const b3Scalar") float getW(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Transform.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Transform.java new file mode 100644 index 00000000000..c393d674a14 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Transform.java @@ -0,0 +1,147 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +// #endif + +/**\brief The b3Transform class supports rigid transforms with only translation and rotation and no scaling/shear. + *It can be used in combination with b3Vector3, b3Quaternion and b3Matrix3x3 linear algebra classes. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Transform extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Transform(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Transform(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Transform position(long position) { + return (b3Transform)super.position(position); + } + @Override public b3Transform getPointer(long i) { + return new b3Transform((Pointer)this).offsetAddress(i); + } + + /**\brief No initialization constructor */ + public b3Transform() { super((Pointer)null); allocate(); } + private native void allocate(); + /**\brief Constructor from b3Quaternion (optional b3Vector3 ) + * @param q Rotation from quaternion + * @param c Translation from Vector (default 0,0,0) */ + public b3Transform(@Const @ByRef b3Quaternion q, + @Const @ByRef(nullValue = "b3Vector3(b3MakeVector3(b3Scalar(0), b3Scalar(0), b3Scalar(0)))") b3Vector3 c) { super((Pointer)null); allocate(q, c); } + private native void allocate(@Const @ByRef b3Quaternion q, + @Const @ByRef(nullValue = "b3Vector3(b3MakeVector3(b3Scalar(0), b3Scalar(0), b3Scalar(0)))") b3Vector3 c); + public b3Transform(@Const @ByRef b3Quaternion q) { super((Pointer)null); allocate(q); } + private native void allocate(@Const @ByRef b3Quaternion q); + + /**\brief Constructor from b3Matrix3x3 (optional b3Vector3) + * @param b Rotation from Matrix + * @param c Translation from Vector default (0,0,0)*/ + public b3Transform(@Const @ByRef b3Matrix3x3 b, + @Const @ByRef(nullValue = "b3Vector3(b3MakeVector3(b3Scalar(0), b3Scalar(0), b3Scalar(0)))") b3Vector3 c) { super((Pointer)null); allocate(b, c); } + private native void allocate(@Const @ByRef b3Matrix3x3 b, + @Const @ByRef(nullValue = "b3Vector3(b3MakeVector3(b3Scalar(0), b3Scalar(0), b3Scalar(0)))") b3Vector3 c); + public b3Transform(@Const @ByRef b3Matrix3x3 b) { super((Pointer)null); allocate(b); } + private native void allocate(@Const @ByRef b3Matrix3x3 b); + /**\brief Copy constructor */ + public b3Transform(@Const @ByRef b3Transform other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef b3Transform other); + /**\brief Assignment Operator */ + public native @ByRef @Name("operator =") b3Transform put(@Const @ByRef b3Transform other); + + /**\brief Set the current transform as the value of the product of two transforms + * @param t1 Transform 1 + * @param t2 Transform 2 + * This = Transform1 * Transform2 */ + public native void mult(@Const @ByRef b3Transform t1, @Const @ByRef b3Transform t2); + + /* void multInverseLeft(const b3Transform& t1, const b3Transform& t2) { + b3Vector3 v = t2.m_origin - t1.m_origin; + m_basis = b3MultTransposeLeft(t1.m_basis, t2.m_basis); + m_origin = v * t1.m_basis; + } + */ + + /**\brief Return the transform of the vector */ + public native @ByVal @Name("operator ()") b3Vector3 apply(@Const @ByRef b3Vector3 x); + + /**\brief Return the transform of the vector */ + public native @ByVal @Name("operator *") b3Vector3 multiply(@Const @ByRef b3Vector3 x); + + /**\brief Return the transform of the b3Quaternion */ + public native @ByVal @Name("operator *") b3Quaternion multiply(@Const @ByRef b3Quaternion q); + + /**\brief Return the basis matrix for the rotation */ + public native @ByRef b3Matrix3x3 getBasis(); + /**\brief Return the basis matrix for the rotation */ + + /**\brief Return the origin vector translation */ + public native @ByRef b3Vector3 getOrigin(); + /**\brief Return the origin vector translation */ + + /**\brief Return a quaternion representing the rotation */ + public native @ByVal b3Quaternion getRotation(); + + /**\brief Set from an array + * @param m A pointer to a 15 element array (12 rotation(row major padded on the right by 1), and 3 translation */ + public native void setFromOpenGLMatrix(@Cast("const b3Scalar*") FloatPointer m); + public native void setFromOpenGLMatrix(@Cast("const b3Scalar*") FloatBuffer m); + public native void setFromOpenGLMatrix(@Cast("const b3Scalar*") float[] m); + + /**\brief Fill an array representation + * @param m A pointer to a 15 element array (12 rotation(row major padded on the right by 1), and 3 translation */ + public native void getOpenGLMatrix(@Cast("b3Scalar*") FloatPointer m); + public native void getOpenGLMatrix(@Cast("b3Scalar*") FloatBuffer m); + public native void getOpenGLMatrix(@Cast("b3Scalar*") float[] m); + + /**\brief Set the translational element + * @param origin The vector to set the translation to */ + public native void setOrigin(@Const @ByRef b3Vector3 origin); + + public native @ByVal b3Vector3 invXform(@Const @ByRef b3Vector3 inVec); + + /**\brief Set the rotational element by b3Matrix3x3 */ + public native void setBasis(@Const @ByRef b3Matrix3x3 basis); + + /**\brief Set the rotational element by b3Quaternion */ + public native void setRotation(@Const @ByRef b3Quaternion q); + + /**\brief Set this transformation to the identity */ + public native void setIdentity(); + + /**\brief Multiply this Transform by another(this = this * another) + * @param t The other transform */ + public native @ByRef @Name("operator *=") b3Transform multiplyPut(@Const @ByRef b3Transform t); + + /**\brief Return the inverse of this transform */ + public native @ByVal b3Transform inverse(); + + /**\brief Return the inverse of this transform times the other transform + * @param t The other transform + * return this.inverse() * the other */ + public native @ByVal b3Transform inverseTimes(@Const @ByRef b3Transform t); + + /**\brief Return the product of this transform and the other */ + public native @ByVal @Name("operator *") b3Transform multiply(@Const @ByRef b3Transform t); + + /**\brief Return an identity transform */ + public static native @Const @ByRef b3Transform getIdentity(); + + public native void serialize(@ByRef b3TransformFloatData dataOut); + + public native void serializeFloat(@ByRef b3TransformFloatData dataOut); + + public native void deSerialize(@Const @ByRef b3TransformFloatData dataIn); + + public native void deSerializeDouble(@Const @ByRef b3TransformDoubleData dataIn); + + public native void deSerializeFloat(@Const @ByRef b3TransformFloatData dataIn); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformDoubleData.java new file mode 100644 index 00000000000..6a92d56178b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformDoubleData.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3TransformDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3TransformDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3TransformDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TransformDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3TransformDoubleData position(long position) { + return (b3TransformDoubleData)super.position(position); + } + @Override public b3TransformDoubleData getPointer(long i) { + return new b3TransformDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Matrix3x3DoubleData m_basis(); public native b3TransformDoubleData m_basis(b3Matrix3x3DoubleData setter); + public native @ByRef b3Vector3DoubleData m_origin(); public native b3TransformDoubleData m_origin(b3Vector3DoubleData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformFloatData.java new file mode 100644 index 00000000000..f55e93968c6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformFloatData.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +/**for serialization */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3TransformFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3TransformFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3TransformFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TransformFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3TransformFloatData position(long position) { + return (b3TransformFloatData)super.position(position); + } + @Override public b3TransformFloatData getPointer(long i) { + return new b3TransformFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Matrix3x3FloatData m_basis(); public native b3TransformFloatData m_basis(b3Matrix3x3FloatData setter); + public native @ByRef b3Vector3FloatData m_origin(); public native b3TransformFloatData m_origin(b3Vector3FloatData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformUtil.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformUtil.java new file mode 100644 index 00000000000..7a93a13f1bf --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TransformUtil.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +/** Utils related to temporal transforms */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3TransformUtil extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3TransformUtil() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3TransformUtil(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TransformUtil(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3TransformUtil position(long position) { + return (b3TransformUtil)super.position(position); + } + @Override public b3TransformUtil getPointer(long i) { + return new b3TransformUtil((Pointer)this).offsetAddress(i); + } + + public static native void integrateTransform(@Const @ByRef b3Transform curTrans, @Const @ByRef b3Vector3 linvel, @Const @ByRef b3Vector3 angvel, @Cast("b3Scalar") float timeStep, @ByRef b3Transform predictedTransform); + + public static native void calculateVelocityQuaternion(@Const @ByRef b3Vector3 pos0, @Const @ByRef b3Vector3 pos1, @Const @ByRef b3Quaternion orn0, @Const @ByRef b3Quaternion orn1, @Cast("b3Scalar") float timeStep, @ByRef b3Vector3 linVel, @ByRef b3Vector3 angVel); + + public static native void calculateDiffAxisAngleQuaternion(@Const @ByRef b3Quaternion orn0, @Const @ByRef b3Quaternion orn1a, @ByRef b3Vector3 axis, @Cast("b3Scalar*") @ByRef FloatPointer angle); + public static native void calculateDiffAxisAngleQuaternion(@Const @ByRef b3Quaternion orn0, @Const @ByRef b3Quaternion orn1a, @ByRef b3Vector3 axis, @Cast("b3Scalar*") @ByRef FloatBuffer angle); + public static native void calculateDiffAxisAngleQuaternion(@Const @ByRef b3Quaternion orn0, @Const @ByRef b3Quaternion orn1a, @ByRef b3Vector3 axis, @Cast("b3Scalar*") @ByRef float[] angle); + + public static native void calculateVelocity(@Const @ByRef b3Transform transform0, @Const @ByRef b3Transform transform1, @Cast("b3Scalar") float timeStep, @ByRef b3Vector3 linVel, @ByRef b3Vector3 angVel); + + public static native void calculateDiffAxisAngle(@Const @ByRef b3Transform transform0, @Const @ByRef b3Transform transform1, @ByRef b3Vector3 axis, @Cast("b3Scalar*") @ByRef FloatPointer angle); + public static native void calculateDiffAxisAngle(@Const @ByRef b3Transform transform0, @Const @ByRef b3Transform transform1, @ByRef b3Vector3 axis, @Cast("b3Scalar*") @ByRef FloatBuffer angle); + public static native void calculateDiffAxisAngle(@Const @ByRef b3Transform transform0, @Const @ByRef b3Transform transform1, @ByRef b3Vector3 axis, @Cast("b3Scalar*") @ByRef float[] angle); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TypedObject.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TypedObject.java new file mode 100644 index 00000000000..c75aafffb8e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3TypedObject.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +/**rudimentary class to provide type info */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3TypedObject extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TypedObject(Pointer p) { super(p); } + + public b3TypedObject(int objectType) { super((Pointer)null); allocate(objectType); } + private native void allocate(int objectType); + public native int m_objectType(); public native b3TypedObject m_objectType(int setter); + public native int getObjectType(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedInt2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedInt2.java new file mode 100644 index 00000000000..7996081925a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedInt2.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +// #ifdef __cplusplus + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3UnsignedInt2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3UnsignedInt2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3UnsignedInt2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3UnsignedInt2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3UnsignedInt2 position(long position) { + return (b3UnsignedInt2)super.position(position); + } + @Override public b3UnsignedInt2 getPointer(long i) { + return new b3UnsignedInt2((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int x(); public native b3UnsignedInt2 x(int setter); + public native @Cast("unsigned int") int y(); public native b3UnsignedInt2 y(int setter); + public native @Cast("unsigned int") int s(int i); public native b3UnsignedInt2 s(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer s(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedInt4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedInt4.java new file mode 100644 index 00000000000..0572760481f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedInt4.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3UnsignedInt4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3UnsignedInt4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3UnsignedInt4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3UnsignedInt4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3UnsignedInt4 position(long position) { + return (b3UnsignedInt4)super.position(position); + } + @Override public b3UnsignedInt4 getPointer(long i) { + return new b3UnsignedInt4((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int x(); public native b3UnsignedInt4 x(int setter); + public native @Cast("unsigned int") int y(); public native b3UnsignedInt4 y(int setter); + public native @Cast("unsigned int") int z(); public native b3UnsignedInt4 z(int setter); + public native @Cast("unsigned int") int w(); public native b3UnsignedInt4 w(int setter); + public native @Cast("unsigned int") int s(int i); public native b3UnsignedInt4 s(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer s(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3.java new file mode 100644 index 00000000000..d656c7f3746 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3.java @@ -0,0 +1,205 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +/**\brief b3Vector3 can be used to represent 3D points and vectors. + * It has an un-used w component to suit 16-byte alignment when b3Vector3 is stored in containers. This extra component can be used by derived classes (Quaternion?) or by user + * Ideally, this class should be replaced by a platform optimized SIMD version that keeps the data in registers + */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Vector3 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Vector3() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Vector3(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Vector3(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Vector3 position(long position) { + return (b3Vector3)super.position(position); + } + @Override public b3Vector3 getPointer(long i) { + return new b3Vector3((Pointer)this).offsetAddress(i); + } + +// #if defined(B3_USE_SSE) || defined(B3_USE_NEON) // _WIN32 || ARM +// #else + public native float m_floats(int i); public native b3Vector3 m_floats(int i, float setter); + @MemberGetter public native FloatPointer m_floats(); + public native float x(); public native b3Vector3 x(float setter); + public native float y(); public native b3Vector3 y(float setter); + public native float z(); public native b3Vector3 z(float setter); + public native float w(); public native b3Vector3 w(float setter); + /**\brief Add a vector to this one + * @param The vector to add to this one */ + public native @ByRef @Name("operator +=") b3Vector3 addPut(@Const @ByRef b3Vector3 v); + + /**\brief Subtract a vector from this one + * @param The vector to subtract */ + public native @ByRef @Name("operator -=") b3Vector3 subtractPut(@Const @ByRef b3Vector3 v); + + /**\brief Scale the vector + * @param s Scale factor */ + public native @ByRef @Name("operator *=") b3Vector3 multiplyPut(@Cast("const b3Scalar") float s); + + /**\brief Inversely scale the vector + * @param s Scale factor to divide by */ + public native @ByRef @Name("operator /=") b3Vector3 dividePut(@Cast("const b3Scalar") float s); + + /**\brief Return the dot product + * @param v The other vector in the dot product */ + public native @Cast("b3Scalar") float dot(@Const @ByRef b3Vector3 v); + + /**\brief Return the length of the vector squared */ + public native @Cast("b3Scalar") float length2(); + + /**\brief Return the length of the vector */ + public native @Cast("b3Scalar") float length(); + + /**\brief Return the distance squared between the ends of this and another vector + * This is symantically treating the vector like a point */ + public native @Cast("b3Scalar") float distance2(@Const @ByRef b3Vector3 v); + + /**\brief Return the distance between the ends of this and another vector + * This is symantically treating the vector like a point */ + public native @Cast("b3Scalar") float distance(@Const @ByRef b3Vector3 v); + + public native @ByRef b3Vector3 safeNormalize(); + + /**\brief Normalize this vector + * x^2 + y^2 + z^2 = 1 */ + public native @ByRef b3Vector3 normalize(); + + /**\brief Return a normalized version of this vector */ + public native @ByVal b3Vector3 normalized(); + + /**\brief Return a rotated version of this vector + * @param wAxis The axis to rotate about + * @param angle The angle to rotate by */ + public native @ByVal b3Vector3 rotate(@Const @ByRef b3Vector3 wAxis, @Cast("const b3Scalar") float angle); + + /**\brief Return the angle between this and another vector + * @param v The other vector */ + public native @Cast("b3Scalar") float angle(@Const @ByRef b3Vector3 v); + + /**\brief Return a vector will the absolute values of each element */ + public native @ByVal b3Vector3 absolute(); + + /**\brief Return the cross product between this and another vector + * @param v The other vector */ + public native @ByVal b3Vector3 cross(@Const @ByRef b3Vector3 v); + + public native @Cast("b3Scalar") float triple(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + + /**\brief Return the axis with the smallest value + * Note return values are 0,1,2 for x, y, or z */ + public native int minAxis(); + + /**\brief Return the axis with the largest value + * Note return values are 0,1,2 for x, y, or z */ + public native int maxAxis(); + + public native int furthestAxis(); + + public native int closestAxis(); + + public native void setInterpolate3(@Const @ByRef b3Vector3 v0, @Const @ByRef b3Vector3 v1, @Cast("b3Scalar") float rt); + + /**\brief Return the linear interpolation between this and another vector + * @param v The other vector + * @param t The ration of this to v (t = 0 => return this, t=1 => return other) */ + public native @ByVal b3Vector3 lerp(@Const @ByRef b3Vector3 v, @Cast("const b3Scalar") float t); + + /**\brief Elementwise multiply this vector by the other + * @param v The other vector */ + public native @ByRef @Name("operator *=") b3Vector3 multiplyPut(@Const @ByRef b3Vector3 v); + + /**\brief Return the x value */ + public native @Cast("const b3Scalar") float getX(); + /**\brief Return the y value */ + public native @Cast("const b3Scalar") float getY(); + /**\brief Return the z value */ + public native @Cast("const b3Scalar") float getZ(); + /**\brief Return the w value */ + public native @Cast("const b3Scalar") float getW(); + + /**\brief Set the x value */ + public native void setX(@Cast("b3Scalar") float _x); + /**\brief Set the y value */ + public native void setY(@Cast("b3Scalar") float _y); + /**\brief Set the z value */ + public native void setZ(@Cast("b3Scalar") float _z); + /**\brief Set the w value */ + public native void setW(@Cast("b3Scalar") float _w); + + //B3_FORCE_INLINE b3Scalar& operator[](int i) { return (&m_floats[0])[i]; } + //B3_FORCE_INLINE const b3Scalar& operator[](int i) const { return (&m_floats[0])[i]; } + /**operator b3Scalar*() replaces operator[], using implicit conversion. We added operator != and operator == to avoid pointer comparisons. */ + public native @Cast("b3Scalar*") @Name("operator b3Scalar*") FloatPointer asFloatPointer(); + + public native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef b3Vector3 other); + + public native @Cast("bool") @Name("operator !=") boolean notEquals(@Const @ByRef b3Vector3 other); + + /**\brief Set each element to the max of the current values and the values of another b3Vector3 + * @param other The other b3Vector3 to compare with + */ + public native void setMax(@Const @ByRef b3Vector3 other); + + /**\brief Set each element to the min of the current values and the values of another b3Vector3 + * @param other The other b3Vector3 to compare with + */ + public native void setMin(@Const @ByRef b3Vector3 other); + + public native void setValue(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z); + + public native void getSkewSymmetricMatrix(b3Vector3 v0, b3Vector3 v1, b3Vector3 v2); + + public native void setZero(); + + public native @Cast("bool") boolean isZero(); + + public native @Cast("bool") boolean fuzzyZero(); + + public native void serialize(@ByRef b3Vector3FloatData dataOut); + + public native void deSerialize(@Const @ByRef b3Vector3FloatData dataIn); + + public native void serializeFloat(@ByRef b3Vector3FloatData dataOut); + + public native void deSerializeFloat(@Const @ByRef b3Vector3FloatData dataIn); + + public native void serializeDouble(@ByRef b3Vector3DoubleData dataOut); + + public native void deSerializeDouble(@Const @ByRef b3Vector3DoubleData dataIn); + + /**\brief returns index of maximum dot product between this and vectors in array[] + * @param array The other vectors + * @param array_count The number of other vectors + * @param dotOut The maximum dot product */ + public native long maxDot(@Const b3Vector3 array, long array_count, @Cast("b3Scalar*") @ByRef FloatPointer dotOut); + public native long maxDot(@Const b3Vector3 array, long array_count, @Cast("b3Scalar*") @ByRef FloatBuffer dotOut); + public native long maxDot(@Const b3Vector3 array, long array_count, @Cast("b3Scalar*") @ByRef float[] dotOut); + + /**\brief returns index of minimum dot product between this and vectors in array[] + * @param array The other vectors + * @param array_count The number of other vectors + * @param dotOut The minimum dot product */ + public native long minDot(@Const b3Vector3 array, long array_count, @Cast("b3Scalar*") @ByRef FloatPointer dotOut); + public native long minDot(@Const b3Vector3 array, long array_count, @Cast("b3Scalar*") @ByRef FloatBuffer dotOut); + public native long minDot(@Const b3Vector3 array, long array_count, @Cast("b3Scalar*") @ByRef float[] dotOut); + + /* create a vector as b3Vector3( this->dot( b3Vector3 v0 ), this->dot( b3Vector3 v1), this->dot( b3Vector3 v2 )) */ + public native @ByVal b3Vector3 dot3(@Const @ByRef b3Vector3 v0, @Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3DoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3DoubleData.java new file mode 100644 index 00000000000..cca7a42fee7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3DoubleData.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Vector3DoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Vector3DoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Vector3DoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Vector3DoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Vector3DoubleData position(long position) { + return (b3Vector3DoubleData)super.position(position); + } + @Override public b3Vector3DoubleData getPointer(long i) { + return new b3Vector3DoubleData((Pointer)this).offsetAddress(i); + } + + public native double m_floats(int i); public native b3Vector3DoubleData m_floats(int i, double setter); + @MemberGetter public native DoublePointer m_floats(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3FloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3FloatData.java new file mode 100644 index 00000000000..8e23db46806 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3FloatData.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Vector3FloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Vector3FloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Vector3FloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Vector3FloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Vector3FloatData position(long position) { + return (b3Vector3FloatData)super.position(position); + } + @Override public b3Vector3FloatData getPointer(long i) { + return new b3Vector3FloatData((Pointer)this).offsetAddress(i); + } + + public native float m_floats(int i); public native b3Vector3FloatData m_floats(int i, float setter); + @MemberGetter public native FloatPointer m_floats(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector4.java new file mode 100644 index 00000000000..b995589b23e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector4.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Vector4 extends b3Vector3 { + static { Loader.load(); } + /** Default native constructor. */ + public b3Vector4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Vector4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Vector4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Vector4 position(long position) { + return (b3Vector4)super.position(position); + } + @Override public b3Vector4 getPointer(long i) { + return new b3Vector4((Pointer)this).offsetAddress(i); + } + + public native @ByVal b3Vector4 absolute4(); + + public native @Cast("b3Scalar") float getW(); + + public native int maxAxis4(); + + public native int minAxis4(); + + public native int closestAxis4(); + + /**\brief Set x,y,z and zero w + * @param x Value of x + * @param y Value of y + * @param z Value of z + */ + + /* void getValue(b3Scalar *m) const + { + m[0] = m_floats[0]; + m[1] = m_floats[1]; + m[2] =m_floats[2]; + } +*/ + /**\brief Set the values + * @param x Value of x + * @param y Value of y + * @param z Value of z + * @param w Value of w + */ + public native void setValue(@Cast("const b3Scalar") float _x, @Cast("const b3Scalar") float _y, @Cast("const b3Scalar") float _z, @Cast("const b3Scalar") float _w); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3WarningMessageFunc.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3WarningMessageFunc.java new file mode 100644 index 00000000000..a2c2197581a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3WarningMessageFunc.java @@ -0,0 +1,21 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3WarningMessageFunc extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3WarningMessageFunc(Pointer p) { super(p); } + protected b3WarningMessageFunc() { allocate(); } + private native void allocate(); + public native void call(@Cast("const char*") BytePointer msg); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java new file mode 100644 index 00000000000..19dfcc37a0e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java @@ -0,0 +1,1154 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.global; + +import org.bytedeco.bullet.Bullet3Common.*; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +public class Bullet3Common extends org.bytedeco.bullet.presets.Bullet3Common { + static { Loader.load(); } + +// Parsed from Bullet3Common/b3AlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_OBJECT_ARRAY__ +// #define B3_OBJECT_ARRAY__ + +// #include "b3Scalar.h" // has definitions like B3_FORCE_INLINE +// #include "b3AlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable B3_USE_PLACEMENT_NEW + * then the b3AlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable B3_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int B3_USE_PLACEMENT_NEW = 1; +//#define B3_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define B3_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef B3_USE_MEMCPY +// #include +// #include +// #endif //B3_USE_MEMCPY + +// #ifdef B3_USE_PLACEMENT_NEW +// #include //for placement new +// #endif //B3_USE_PLACEMENT_NEW + +/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ + +// #endif //B3_OBJECT_ARRAY__ + + +// Parsed from Bullet3Common/b3CommandLineArgs.h + +// #ifndef COMMAND_LINE_ARGS_H +// #define COMMAND_LINE_ARGS_H + +/****************************************************************************** + * Command-line parsing + ******************************************************************************/ +// #include +// #include +// #include +// #include +// #include +// Targeting ../Bullet3Common/b3CommandLineArgs.java + + + + + + + +// #endif //COMMAND_LINE_ARGS_H + + +// Parsed from Bullet3Common/b3FileUtils.h + +// #ifndef B3_FILE_UTILS_H +// #define B3_FILE_UTILS_H + +// #include +// #include "b3Scalar.h" +// #include //ptrdiff_h +// #include +// Targeting ../Bullet3Common/b3FileUtils.java + + +// #endif //B3_FILE_UTILS_H + + +// Parsed from Bullet3Common/b3HashMap.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_HASH_MAP_H +// #define B3_HASH_MAP_H + +// #include "b3AlignedObjectArray.h" + +// #include +// Targeting ../Bullet3Common/b3HashString.java + + + +@MemberGetter public static native int B3_HASH_NULL(); +// Targeting ../Bullet3Common/b3HashInt.java + + +// Targeting ../Bullet3Common/b3HashPtr.java + + + +/**The b3HashMap template class implements a generic and lightweight hashmap. + * A basic sample of how to use b3HashMap is located in Demos\BasicDemo\main.cpp */ + +// #endif //B3_HASH_MAP_H + + +// Parsed from Bullet3Common/b3Logging.h + + +// #ifndef B3_LOGGING_H +// #define B3_LOGGING_H + +// #ifdef __cplusplus +// #endif + +/**We add the do/while so that the statement "if (condition) b3Printf("test"); else {...}" would fail + * You can also customize the message by uncommenting out a different line below */ +// #define b3Printf(...) b3OutputPrintfVarArgsInternal(__VA_ARGS__) + //#define b3Printf(...) do {b3OutputPrintfVarArgsInternal("b3Printf[%s,%d]:",__FILE__,__LINE__);b3OutputPrintfVarArgsInternal(__VA_ARGS__); } while(0) + //#define b3Printf b3OutputPrintfVarArgsInternal + //#define b3Printf(...) printf(__VA_ARGS__) + //#define b3Printf(...) +// #define b3Warning(...) do{ b3OutputWarningMessageVarArgsInternal("b3Warning[%s,%d]:\n", __FILE__, __LINE__);b3OutputWarningMessageVarArgsInternal(__VA_ARGS__);} while (0) +// #define b3Error(...)do {b3OutputErrorMessageVarArgsInternal("b3Error[%s,%d]:\n", __FILE__, __LINE__);b3OutputErrorMessageVarArgsInternal(__VA_ARGS__);} while (0) +// #ifndef B3_NO_PROFILE + + public static native void b3EnterProfileZone(@Cast("const char*") BytePointer name); + public static native void b3EnterProfileZone(String name); + public static native void b3LeaveProfileZone(); +// Targeting ../Bullet3Common/b3ProfileZone.java + + + +// #define B3_PROFILE(name) b3ProfileZone __profile(name) +// #endif + +// #else //B3_NO_PROFILE + +// #define B3_PROFILE(name) +// #define b3StartProfile(a) +// #define b3StopProfile +// Targeting ../Bullet3Common/b3PrintfFunc.java + + +// Targeting ../Bullet3Common/b3WarningMessageFunc.java + + +// Targeting ../Bullet3Common/b3ErrorMessageFunc.java + + +// Targeting ../Bullet3Common/b3EnterProfileZoneFunc.java + + +// Targeting ../Bullet3Common/b3LeaveProfileZoneFunc.java + + + + /**The developer can route b3Printf output using their own implementation */ + public static native void b3SetCustomPrintfFunc(b3PrintfFunc printfFunc); + public static native void b3SetCustomWarningMessageFunc(b3WarningMessageFunc warningMsgFunc); + public static native void b3SetCustomErrorMessageFunc(b3ErrorMessageFunc errorMsgFunc); + + /**Set custom profile zone functions (zones can be nested) */ + public static native void b3SetCustomEnterProfileZoneFunc(b3EnterProfileZoneFunc enterFunc); + public static native void b3SetCustomLeaveProfileZoneFunc(b3LeaveProfileZoneFunc leaveFunc); + + /**Don't use those internal functions directly, use the b3Printf or b3SetCustomPrintfFunc instead (or warning/error version) */ + public static native void b3OutputPrintfVarArgsInternal(@Cast("const char*") BytePointer str); + public static native void b3OutputPrintfVarArgsInternal(String str); + public static native void b3OutputWarningMessageVarArgsInternal(@Cast("const char*") BytePointer str); + public static native void b3OutputWarningMessageVarArgsInternal(String str); + public static native void b3OutputErrorMessageVarArgsInternal(@Cast("const char*") BytePointer str); + public static native void b3OutputErrorMessageVarArgsInternal(String str); + +// #ifdef __cplusplus +// #endif + +// #endif //B3_LOGGING_H + +// Parsed from Bullet3Common/b3Scalar.h + +/* +Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_SCALAR_H +// #define B3_SCALAR_H + +// #ifdef B3_MANAGED_CODE +//Aligned data types not supported in managed code +// #pragma unmanaged +// #endif + +// #include +// #include //size_t for MSVC 6.0 +// #include + +//Original repository is at http://github.com/erwincoumans/bullet3 +public static final int B3_BULLET_VERSION = 300; + +public static native int b3GetVersion(); + +// #if defined(DEBUG) || defined(_DEBUG) +// #define B3_DEBUG +// #endif + +// #include "b3Logging.h" //for b3Error + +// #ifdef _WIN32 + +// #else + +// #if defined(__CELLOS_LV2__) +// #define B3_FORCE_INLINE inline __attribute__((always_inline)) +// #define B3_ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16))) +// #define B3_ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64))) +// #define B3_ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128))) +// #ifndef assert +// #include +// #endif +// #ifdef B3_DEBUG + +// #else +// #define b3Assert(x) +// #endif +//b3FullAssert is optional, slows down a lot +// #define b3FullAssert(x) + +// #define b3Likely(_c) _c +// #define b3Unlikely(_c) _c + +// #else + +// #ifdef USE_LIBSPE2 + +// #define B3_FORCE_INLINE __inline +// #define B3_ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16))) +// #define B3_ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64))) +// #define B3_ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128))) +// #ifndef assert +// #include +// #endif +// #ifdef B3_DEBUG +// #else +// #define b3Assert(x) +// #endif +//b3FullAssert is optional, slows down a lot +// #define b3FullAssert(x) + +// #define b3Likely(_c) __builtin_expect((_c), 1) +// #define b3Unlikely(_c) __builtin_expect((_c), 0) + +// #else +//non-windows systems + +// #if (defined(__APPLE__) && (!defined(B3_USE_DOUBLE_PRECISION))) +// #if defined(__i386__) || defined(__x86_64__) +// #define B3_USE_SSE +//B3_USE_SSE_IN_API is enabled on Mac OSX by default, because memory is automatically aligned on 16-byte boundaries +//if apps run into issues, we will disable the next line +// #define B3_USE_SSE_IN_API +// #ifdef B3_USE_SSE +// #endif //B3_USE_SSE +// #elif defined(__armv7__) +// #ifdef __clang__ +// #endif //__clang__ +// #endif //__arm__ + +// #define B3_FORCE_INLINE inline __attribute__((always_inline)) +/**\todo: check out alignment methods for other platforms/compilers */ +// #define B3_ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16))) +// #define B3_ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64))) +// #define B3_ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128))) +// #ifndef assert +// #include +// #endif + +// #if defined(DEBUG) || defined(_DEBUG) +// #if defined(__i386__) || defined(__x86_64__) +// #include +// #define b3Assert(x) +// { +// if (!(x)) +// { +// b3Error("Assert %s in line %d, file %s\n", #x, __LINE__, __FILE__); +// asm volatile("int3"); +// } +// } +// #else //defined (__i386__) || defined (__x86_64__) +// #define b3Assert assert +// #endif //defined (__i386__) || defined (__x86_64__) +// #else //defined(DEBUG) || defined (_DEBUG) +// #define b3Assert(x) +// #endif //defined(DEBUG) || defined (_DEBUG) + +//b3FullAssert is optional, slows down a lot +// #define b3FullAssert(x) +// #define b3Likely(_c) _c +// #define b3Unlikely(_c) _c + +// #else + +// #define B3_FORCE_INLINE inline +/**\todo: check out alignment methods for other platforms/compilers */ +// #define B3_ATTRIBUTE_ALIGNED16(a) a __attribute__((aligned(16))) +// #define B3_ATTRIBUTE_ALIGNED64(a) a __attribute__((aligned(64))) +// #define B3_ATTRIBUTE_ALIGNED128(a) a __attribute__((aligned(128))) +/**#define B3_ATTRIBUTE_ALIGNED16(a) a + * #define B3_ATTRIBUTE_ALIGNED64(a) a + * #define B3_ATTRIBUTE_ALIGNED128(a) a */ +// #ifndef assert +// #include +// #endif + +// #if defined(DEBUG) || defined(_DEBUG) +// #define b3Assert assert +// #else +// #define b3Assert(x) +// #endif + +//b3FullAssert is optional, slows down a lot +// #define b3FullAssert(x) +// #define b3Likely(_c) _c +// #define b3Unlikely(_c) _c +// #endif //__APPLE__ + +// #endif // LIBSPE2 + +// #endif //__CELLOS_LV2__ +// #endif + +/**The b3Scalar type abstracts floating point numbers, to easily switch between double and single floating point precision. */ +// #if defined(B3_USE_DOUBLE_PRECISION) +// #else +//keep B3_LARGE_FLOAT*B3_LARGE_FLOAT < FLT_MAX +public static native @MemberGetter float B3_LARGE_FLOAT(); +public static final float B3_LARGE_FLOAT = B3_LARGE_FLOAT(); +// #endif + +// #ifdef B3_USE_SSE +// #endif //B3_USE_SSE + +// #if defined B3_USE_SSE_IN_API && defined(B3_USE_SSE) +// #ifdef _WIN32 + +// #else //_WIN32 + +// #define b3CastfTo128i(a) ((__m128i)(a)) +// #define b3CastfTo128d(a) ((__m128d)(a)) +// #define b3CastiTo128f(a) ((__m128)(a)) +// #define b3CastdTo128f(a) ((__m128)(a)) +// #define b3CastdTo128i(a) ((__m128i)(a)) +// #define b3Assign128(r0, r1, r2, r3) +// (__m128) { r0, r1, r2, r3 } +// #endif //_WIN32 +// #endif //B3_USE_SSE_IN_API + +// #ifdef B3_USE_NEON +// #endif + +// #define B3_DECLARE_ALIGNED_ALLOCATOR() +// B3_FORCE_INLINE void *operator new(size_t sizeInBytes) { return b3AlignedAlloc(sizeInBytes, 16); } +// B3_FORCE_INLINE void operator delete(void *ptr) { b3AlignedFree(ptr); } +// B3_FORCE_INLINE void *operator new(size_t, void *ptr) { return ptr; } +// B3_FORCE_INLINE void operator delete(void *, void *) {} +// B3_FORCE_INLINE void *operator new[](size_t sizeInBytes) { return b3AlignedAlloc(sizeInBytes, 16); } +// B3_FORCE_INLINE void operator delete[](void *ptr) { b3AlignedFree(ptr); } +// B3_FORCE_INLINE void *operator new[](size_t, void *ptr) { return ptr; } +// B3_FORCE_INLINE void operator delete[](void *, void *) {} + +// #if defined(B3_USE_DOUBLE_PRECISION) || defined(B3_FORCE_DOUBLE_FUNCTIONS) + +// #else + +public static native @Cast("b3Scalar") float b3Sqrt(@Cast("b3Scalar") float y); +public static native @Cast("b3Scalar") float b3Fabs(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Cos(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Sin(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Tan(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Acos(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Asin(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Atan(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Atan2(@Cast("b3Scalar") float x, @Cast("b3Scalar") float y); +public static native @Cast("b3Scalar") float b3Exp(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Log(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Pow(@Cast("b3Scalar") float x, @Cast("b3Scalar") float y); +public static native @Cast("b3Scalar") float b3Fmod(@Cast("b3Scalar") float x, @Cast("b3Scalar") float y); + +// #endif + +public static native @MemberGetter double B3_2_PI(); +public static final double B3_2_PI = B3_2_PI(); +public static native @MemberGetter double B3_PI(); +public static final double B3_PI = B3_PI(); +public static native @MemberGetter double B3_HALF_PI(); +public static final double B3_HALF_PI = B3_HALF_PI(); +public static native @MemberGetter double B3_RADS_PER_DEG(); +public static final double B3_RADS_PER_DEG = B3_RADS_PER_DEG(); +public static native @MemberGetter double B3_DEGS_PER_RAD(); +public static final double B3_DEGS_PER_RAD = B3_DEGS_PER_RAD(); +public static native @MemberGetter double B3_SQRT12(); +public static final double B3_SQRT12 = B3_SQRT12(); + +// #define b3RecipSqrt(x) ((b3Scalar)(b3Scalar(1.0) / b3Sqrt(b3Scalar(x)))) /* reciprocal square root */ + +// #ifdef B3_USE_DOUBLE_PRECISION +// #else +public static native @MemberGetter float B3_EPSILON(); +public static final float B3_EPSILON = B3_EPSILON(); +public static native @MemberGetter float B3_INFINITY(); +public static final float B3_INFINITY = B3_INFINITY(); +// #endif + +public static native @Cast("b3Scalar") float b3Atan2Fast(@Cast("b3Scalar") float y, @Cast("b3Scalar") float x); + +public static native @Cast("bool") boolean b3FuzzyZero(@Cast("b3Scalar") float x); + +public static native @Cast("bool") boolean b3Equal(@Cast("b3Scalar") float a, @Cast("b3Scalar") float eps); +public static native @Cast("bool") boolean b3GreaterEqual(@Cast("b3Scalar") float a, @Cast("b3Scalar") float eps); + +public static native int b3IsNegative(@Cast("b3Scalar") float x); + +public static native @Cast("b3Scalar") float b3Radians(@Cast("b3Scalar") float x); +public static native @Cast("b3Scalar") float b3Degrees(@Cast("b3Scalar") float x); + +// #define B3_DECLARE_HANDLE(name) +// typedef struct name##__ +// { +// int unused; +// } * name + +// #ifndef b3Fsel +public static native @Cast("b3Scalar") float b3Fsel(@Cast("b3Scalar") float a, @Cast("b3Scalar") float b, @Cast("b3Scalar") float c); +// #endif +// #define b3Fsels(a, b, c) (b3Scalar) b3Fsel(a, b, c) + +public static native @Cast("bool") boolean b3MachineIsLittleEndian(); + +/**b3Select avoids branches, which makes performance much better for consoles like Playstation 3 and XBox 360 + * Thanks Phil Knight. See also http://www.cellperformance.com/articles/2006/04/more_techniques_for_eliminatin_1.html */ +public static native @Cast("unsigned") int b3Select(@Cast("unsigned") int condition, @Cast("unsigned") int valueIfConditionNonZero, @Cast("unsigned") int valueIfConditionZero); +public static native float b3Select(@Cast("unsigned") int condition, float valueIfConditionNonZero, float valueIfConditionZero); + +//PCK: endian swapping functions +public static native @Cast("unsigned") int b3SwapEndian(@Cast("unsigned") int val); + +public static native @Cast("unsigned short") short b3SwapEndian(@Cast("unsigned short") short val); + +/**b3SwapFloat uses using char pointers to swap the endianness +////b3SwapFloat/b3SwapDouble will NOT return a float, because the machine might 'correct' invalid floating point values + * Not all values of sign/exponent/mantissa are valid floating point numbers according to IEEE 754. + * When a floating point unit is faced with an invalid value, it may actually change the value, or worse, throw an exception. + * In most systems, running user mode code, you wouldn't get an exception, but instead the hardware/os/runtime will 'fix' the number for you. + * so instead of returning a float/double, we return integer/long long integer */ +public static native @Cast("unsigned int") int b3SwapEndianFloat(float d); + +// unswap using char pointers +public static native float b3UnswapEndianFloat(@Cast("unsigned int") int a); + +// swap using char pointers +public static native void b3SwapEndianDouble(double d, @Cast("unsigned char*") BytePointer dst); +public static native void b3SwapEndianDouble(double d, @Cast("unsigned char*") ByteBuffer dst); +public static native void b3SwapEndianDouble(double d, @Cast("unsigned char*") byte[] dst); + +// unswap using char pointers +public static native double b3UnswapEndianDouble(@Cast("const unsigned char*") BytePointer src); +public static native double b3UnswapEndianDouble(@Cast("const unsigned char*") ByteBuffer src); +public static native double b3UnswapEndianDouble(@Cast("const unsigned char*") byte[] src); + +// returns normalized value in range [-B3_PI, B3_PI] +public static native @Cast("b3Scalar") float b3NormalizeAngle(@Cast("b3Scalar") float angleInRadians); +// Targeting ../Bullet3Common/b3TypedObject.java + + + +/**align a pointer to the provided alignment, upwards */ + +// #endif //B3_SCALAR_H + + +// Parsed from Bullet3Common/b3Vector3.h + +/* +Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_VECTOR3_H +// #define B3_VECTOR3_H + +//#include +// #include "b3Scalar.h" +// #include "b3MinMax.h" +// #include "b3AlignedAllocator.h" + +// #ifdef B3_USE_DOUBLE_PRECISION +// #else +// #define b3Vector3Data b3Vector3FloatData +public static final String b3Vector3DataName = "b3Vector3FloatData"; +// #endif //B3_USE_DOUBLE_PRECISION + +// #if defined B3_USE_SSE + +// #endif + +// #ifdef B3_USE_NEON + +// #endif + +// #if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE) +// #endif + +public static native @ByVal b3Vector3 b3MakeVector3(@Cast("b3Scalar") float x, @Cast("b3Scalar") float y, @Cast("b3Scalar") float z); +public static native @ByVal b3Vector3 b3MakeVector3(@Cast("b3Scalar") float x, @Cast("b3Scalar") float y, @Cast("b3Scalar") float z, @Cast("b3Scalar") float w); +public static native @ByVal b3Vector4 b3MakeVector4(@Cast("b3Scalar") float x, @Cast("b3Scalar") float y, @Cast("b3Scalar") float z, @Cast("b3Scalar") float w); +// Targeting ../Bullet3Common/b3Vector3.java + + + +/**\brief Return the sum of two vectors (Point symantics)*/ +public static native @ByVal @Name("operator +") b3Vector3 add(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +/**\brief Return the elementwise product of two vectors */ +public static native @ByVal @Name("operator *") b3Vector3 multiply(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +/**\brief Return the difference between two vectors */ +public static native @ByVal @Name("operator -") b3Vector3 subtract(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +/**\brief Return the negative of the vector */ +public static native @ByVal @Name("operator -") b3Vector3 subtract(@Const @ByRef b3Vector3 v); + +/**\brief Return the vector scaled by s */ +public static native @ByVal @Name("operator *") b3Vector3 multiply(@Const @ByRef b3Vector3 v, @Cast("const b3Scalar") float s); + +/**\brief Return the vector scaled by s */ +public static native @ByVal @Name("operator *") b3Vector3 multiply(@Cast("const b3Scalar") float s, @Const @ByRef b3Vector3 v); + +/**\brief Return the vector inversely scaled by s */ +public static native @ByVal @Name("operator /") b3Vector3 divide(@Const @ByRef b3Vector3 v, @Cast("const b3Scalar") float s); + +/**\brief Return the vector inversely scaled by s */ +public static native @ByVal @Name("operator /") b3Vector3 divide(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +/**\brief Return the dot product between two vectors */ +public static native @Cast("b3Scalar") float b3Dot(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +/**\brief Return the distance squared between two vectors */ +public static native @Cast("b3Scalar") float b3Distance2(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +/**\brief Return the distance between two vectors */ +public static native @Cast("b3Scalar") float b3Distance(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +/**\brief Return the angle between two vectors */ +public static native @Cast("b3Scalar") float b3Angle(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +/**\brief Return the cross product of two vectors */ +public static native @ByVal b3Vector3 b3Cross(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2); + +public static native @Cast("b3Scalar") float b3Triple(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2, @Const @ByRef b3Vector3 v3); + +/**\brief Return the linear interpolation between two vectors + * @param v1 One vector + * @param v2 The other vector + * @param t The ration of this to v (t = 0 => return v1, t=1 => return v2) */ +public static native @ByVal b3Vector3 b3Lerp(@Const @ByRef b3Vector3 v1, @Const @ByRef b3Vector3 v2, @Cast("const b3Scalar") float t); + + + + + + + + + + + + +// Targeting ../Bullet3Common/b3Vector4.java + + + +/**b3SwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void b3SwapScalarEndian(@Cast("const b3Scalar") float sourceVal, @Cast("b3Scalar*") @ByRef FloatPointer destVal); +public static native void b3SwapScalarEndian(@Cast("const b3Scalar") float sourceVal, @Cast("b3Scalar*") @ByRef FloatBuffer destVal); +public static native void b3SwapScalarEndian(@Cast("const b3Scalar") float sourceVal, @Cast("b3Scalar*") @ByRef float[] destVal); +/**b3SwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void b3SwapVector3Endian(@Const @ByRef b3Vector3 sourceVec, @ByRef b3Vector3 destVec); + +/**b3UnSwapVector3Endian swaps vector endianness, useful for network and cross-platform serialization */ +public static native void b3UnSwapVector3Endian(@ByRef b3Vector3 vector); +// Targeting ../Bullet3Common/b3Vector3FloatData.java + + +// Targeting ../Bullet3Common/b3Vector3DoubleData.java + + + + + + + + + + + + + + + +// #if defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE) + +// #endif + +// #endif //B3_VECTOR3_H + + +// Parsed from Bullet3Common/b3QuadWord.h + +/* +Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_SIMD_QUADWORD_H +// #define B3_SIMD_QUADWORD_H + +// #include "b3Scalar.h" +// #include "b3MinMax.h" + +// #if defined(__CELLOS_LV2) && defined(__SPU__) +// #include +// Targeting ../Bullet3Common/b3QuadWord.java + + + +// #endif //B3_SIMD_QUADWORD_H + + +// Parsed from Bullet3Common/b3Quaternion.h + +/* +Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_SIMD__QUATERNION_H_ +// #define B3_SIMD__QUATERNION_H_ + +// #include "b3Vector3.h" +// #include "b3QuadWord.h" +// Targeting ../Bullet3Common/b3Quaternion.java + + + +/**\brief Return the product of two quaternions */ +public static native @ByVal @Name("operator *") b3Quaternion multiply(@Const @ByRef b3Quaternion q1, @Const @ByRef b3Quaternion q2); + +public static native @ByVal @Name("operator *") b3Quaternion multiply(@Const @ByRef b3Quaternion q, @Const @ByRef b3Vector3 w); + +public static native @ByVal @Name("operator *") b3Quaternion multiply(@Const @ByRef b3Vector3 w, @Const @ByRef b3Quaternion q); + +/**\brief Calculate the dot product between two quaternions */ +public static native @Cast("b3Scalar") float b3Dot(@Const @ByRef b3Quaternion q1, @Const @ByRef b3Quaternion q2); + +/**\brief Return the length of a quaternion */ +public static native @Cast("b3Scalar") float b3Length(@Const @ByRef b3Quaternion q); + +/**\brief Return the angle between two quaternions*/ +public static native @Cast("b3Scalar") float b3Angle(@Const @ByRef b3Quaternion q1, @Const @ByRef b3Quaternion q2); + +/**\brief Return the inverse of a quaternion*/ +public static native @ByVal b3Quaternion b3Inverse(@Const @ByRef b3Quaternion q); + +/**\brief Return the result of spherical linear interpolation betwen two quaternions + * @param q1 The first quaternion + * @param q2 The second quaternion + * @param t The ration between q1 and q2. t = 0 return q1, t=1 returns q2 + * Slerp assumes constant velocity between positions. */ +public static native @ByVal b3Quaternion b3Slerp(@Const @ByRef b3Quaternion q1, @Const @ByRef b3Quaternion q2, @Cast("const b3Scalar") float t); + +public static native @ByVal b3Quaternion b3QuatMul(@Const @ByRef b3Quaternion rot0, @Const @ByRef b3Quaternion rot1); + +public static native @ByVal b3Quaternion b3QuatNormalized(@Const @ByRef b3Quaternion orn); + +public static native @ByVal b3Vector3 b3QuatRotate(@Const @ByRef b3Quaternion rotation, @Const @ByRef b3Vector3 v); + +public static native @ByVal b3Quaternion b3ShortestArcQuat(@Const @ByRef b3Vector3 v0, @Const @ByRef b3Vector3 v1); + +public static native @ByVal b3Quaternion b3ShortestArcQuatNormalize2(@ByRef b3Vector3 v0, @ByRef b3Vector3 v1); + +// #endif //B3_SIMD__QUATERNION_H_ + + +// Parsed from Bullet3Common/b3Matrix3x3.h + +/* +Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_MATRIX3x3_H +// #define B3_MATRIX3x3_H + +// #include "b3Vector3.h" +// #include "b3Quaternion.h" +// #include + +// #ifdef B3_USE_SSE +// #endif + +// #if defined(B3_USE_SSE) || defined(B3_USE_NEON) +// #endif + +// #ifdef B3_USE_DOUBLE_PRECISION +// #else +// #define b3Matrix3x3Data b3Matrix3x3FloatData +// Targeting ../Bullet3Common/b3Matrix3x3.java + + + + + + + +public static native @ByVal @Name("operator *") b3Matrix3x3 multiply(@Const @ByRef b3Matrix3x3 m, @Cast("const b3Scalar") float k); + +public static native @ByVal @Name("operator +") b3Matrix3x3 add(@Const @ByRef b3Matrix3x3 m1, @Const @ByRef b3Matrix3x3 m2); + +public static native @ByVal @Name("operator -") b3Matrix3x3 subtract(@Const @ByRef b3Matrix3x3 m1, @Const @ByRef b3Matrix3x3 m2); + + + + + + + + + + + + + + + + + +public static native @ByVal @Name("operator *") b3Vector3 multiply(@Const @ByRef b3Matrix3x3 m, @Const @ByRef b3Vector3 v); + +public static native @ByVal @Name("operator *") b3Vector3 multiply(@Const @ByRef b3Vector3 v, @Const @ByRef b3Matrix3x3 m); + +public static native @ByVal @Name("operator *") b3Matrix3x3 multiply(@Const @ByRef b3Matrix3x3 m1, @Const @ByRef b3Matrix3x3 m2); + +/* +B3_FORCE_INLINE b3Matrix3x3 b3MultTransposeLeft(const b3Matrix3x3& m1, const b3Matrix3x3& m2) { +return b3Matrix3x3( +m1[0][0] * m2[0][0] + m1[1][0] * m2[1][0] + m1[2][0] * m2[2][0], +m1[0][0] * m2[0][1] + m1[1][0] * m2[1][1] + m1[2][0] * m2[2][1], +m1[0][0] * m2[0][2] + m1[1][0] * m2[1][2] + m1[2][0] * m2[2][2], +m1[0][1] * m2[0][0] + m1[1][1] * m2[1][0] + m1[2][1] * m2[2][0], +m1[0][1] * m2[0][1] + m1[1][1] * m2[1][1] + m1[2][1] * m2[2][1], +m1[0][1] * m2[0][2] + m1[1][1] * m2[1][2] + m1[2][1] * m2[2][2], +m1[0][2] * m2[0][0] + m1[1][2] * m2[1][0] + m1[2][2] * m2[2][0], +m1[0][2] * m2[0][1] + m1[1][2] * m2[1][1] + m1[2][2] * m2[2][1], +m1[0][2] * m2[0][2] + m1[1][2] * m2[1][2] + m1[2][2] * m2[2][2]); +} +*/ + +/**\brief Equality operator between two matrices +* It will test all elements are equal. */ +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef b3Matrix3x3 m1, @Const @ByRef b3Matrix3x3 m2); +// Targeting ../Bullet3Common/b3Matrix3x3FloatData.java + + +// Targeting ../Bullet3Common/b3Matrix3x3DoubleData.java + + + + + + + + + + + + + +// #endif //B3_MATRIX3x3_H + + +// Parsed from Bullet3Common/b3MinMax.h + +/* +Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_GEN_MINMAX_H +// #define B3_GEN_MINMAX_H + +// #include "b3Scalar.h" + +// #endif //B3_GEN_MINMAX_H + + +// Parsed from Bullet3Common/b3ResizablePool.h + + +// #ifndef B3_RESIZABLE_POOL_H +// #define B3_RESIZABLE_POOL_H + +// #include "Bullet3Common/b3AlignedObjectArray.h" + +/** enum */ +public static final int + B3_POOL_HANDLE_TERMINAL_FREE = -1, + B3_POOL_HANDLE_TERMINAL_USED = -2; +/**end handle management */ + +// #endif //B3_RESIZABLE_POOL_H + + +// Parsed from Bullet3Common/b3Transform.h + +/* +Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_TRANSFORM_H +// #define B3_TRANSFORM_H + +// #include "b3Matrix3x3.h" + +// #ifdef B3_USE_DOUBLE_PRECISION +// #else +// #define b3TransformData b3TransformFloatData +// Targeting ../Bullet3Common/b3Transform.java + + + + + + + + + +/**\brief Test if two transforms have all elements equal */ +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef b3Transform t1, @Const @ByRef b3Transform t2); +// Targeting ../Bullet3Common/b3TransformFloatData.java + + +// Targeting ../Bullet3Common/b3TransformDoubleData.java + + + + + + + + + + + + + +// #endif //B3_TRANSFORM_H + + +// Parsed from Bullet3Common/b3TransformUtil.h + +/* +Copyright (c) 2003-2013 Gino van den Bergen / Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_TRANSFORM_UTIL_H +// #define B3_TRANSFORM_UTIL_H + +// #include "b3Transform.h" +public static native @MemberGetter double B3_ANGULAR_MOTION_THRESHOLD(); +public static final double B3_ANGULAR_MOTION_THRESHOLD = B3_ANGULAR_MOTION_THRESHOLD(); + +public static native @ByVal b3Vector3 b3AabbSupport(@Const @ByRef b3Vector3 halfExtents, @Const @ByRef b3Vector3 supportDir); +// Targeting ../Bullet3Common/b3TransformUtil.java + + +// Targeting ../Bullet3Common/b3ConvexSeparatingDistanceUtil.java + + + +// #endif //B3_TRANSFORM_UTIL_H + + +// Parsed from Bullet3Common/shared/b3Float4.h + +// #ifndef B3_FLOAT4_H +// #define B3_FLOAT4_H + +// #include "Bullet3Common/shared/b3PlatformDefinitions.h" + +// #ifdef __cplusplus +// #include "Bullet3Common/b3Vector3.h" +// #define b3Float4 b3Vector3 +// #define b3Float4ConstArg const b3Vector3& +// #define b3Dot3F4 b3Dot +// #define b3Cross3 b3Cross +// #define b3MakeFloat4 b3MakeVector3 +public static native @ByVal b3Vector3 b3Normalized(@Const @ByRef b3Vector3 vec); + +public static native @ByVal b3Vector3 b3FastNormalized3(@Const @ByRef b3Vector3 v); + +public static native @ByVal b3Vector3 b3MaxFloat4(@Const @ByRef b3Vector3 a, @Const @ByRef b3Vector3 b); +public static native @ByVal b3Vector3 b3MinFloat4(@Const @ByRef b3Vector3 a, @Const @ByRef b3Vector3 b); + +// #else + +// #endif + +public static native @Cast("bool") boolean b3IsAlmostZero(@Const @ByRef b3Vector3 v); + +public static native int b3MaxDot(@Const @ByRef b3Vector3 vec, @Const b3Vector3 vecArray, int vecLen, FloatPointer dotOut); +public static native int b3MaxDot(@Const @ByRef b3Vector3 vec, @Const b3Vector3 vecArray, int vecLen, FloatBuffer dotOut); +public static native int b3MaxDot(@Const @ByRef b3Vector3 vec, @Const b3Vector3 vecArray, int vecLen, float[] dotOut); + +// #endif //B3_FLOAT4_H + + +// Parsed from Bullet3Common/shared/b3Int2.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_INT2_H +// #define B3_INT2_H +// Targeting ../Bullet3Common/b3UnsignedInt2.java + + +// Targeting ../Bullet3Common/b3Int2.java + + + +public static native @ByVal b3Int2 b3MakeInt2(int x, int y); +// #else + +// #endif //__cplusplus +// #endif + +// Parsed from Bullet3Common/shared/b3Int4.h + +// #ifndef B3_INT4_H +// #define B3_INT4_H + +// #ifdef __cplusplus + +// #include "Bullet3Common/b3Scalar.h" +// Targeting ../Bullet3Common/b3UnsignedInt4.java + + +// Targeting ../Bullet3Common/b3Int4.java + + + +public static native @ByVal b3Int4 b3MakeInt4(int x, int y, int z, int w/*=0*/); +public static native @ByVal b3Int4 b3MakeInt4(int x, int y, int z); + +public static native @ByVal b3UnsignedInt4 b3MakeUnsignedInt4(@Cast("unsigned int") int x, @Cast("unsigned int") int y, @Cast("unsigned int") int z, @Cast("unsigned int") int w/*=0*/); +public static native @ByVal b3UnsignedInt4 b3MakeUnsignedInt4(@Cast("unsigned int") int x, @Cast("unsigned int") int y, @Cast("unsigned int") int z); + +// #else + +// #endif //__cplusplus + +// #endif //B3_INT4_H + + +// Parsed from Bullet3Common/shared/b3Quat.h + +// #ifndef B3_QUAT_H +// #define B3_QUAT_H + +// #include "Bullet3Common/shared/b3PlatformDefinitions.h" +// #include "Bullet3Common/shared/b3Float4.h" + +// #ifdef __cplusplus +// #include "Bullet3Common/b3Quaternion.h" +// #include "Bullet3Common/b3Transform.h" + +// #define b3Quat b3Quaternion +// #define b3QuatConstArg const b3Quaternion& +public static native @ByVal b3Quaternion b3QuatInverse(@Const @ByRef b3Quaternion orn); + +public static native @ByVal b3Vector3 b3TransformPoint(@Const @ByRef b3Vector3 point, @Const @ByRef b3Vector3 translation, @Const @ByRef b3Quaternion orientation); + +// #else + +// #endif + +// #endif //B3_QUAT_H + + +// Parsed from Bullet3Common/shared/b3Mat3x3.h + + +// #ifndef B3_MAT3x3_H +// #define B3_MAT3x3_H + +// #include "Bullet3Common/shared/b3Quat.h" + +// #ifdef __cplusplus + +// #include "Bullet3Common/b3Matrix3x3.h" + +// #define b3Mat3x3 b3Matrix3x3 +// #define b3Mat3x3ConstArg const b3Matrix3x3& + +public static native @ByVal b3Matrix3x3 b3QuatGetRotationMatrix(@Const @ByRef b3Quaternion quat); + +public static native @ByVal b3Matrix3x3 b3AbsoluteMat3x3(@Const @ByRef b3Matrix3x3 mat); + +// #define b3GetRow(m, row) m.getRow(row) + +public static native @ByVal b3Vector3 mtMul3(@Const @ByRef b3Vector3 a, @Const @ByRef b3Matrix3x3 b); + +// #else + +// #endif + +// #endif //B3_MAT3x3_H + + +} From d28c759d5f346b39771a9f7052b6ac6bc9655fb5 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 3 Mar 2022 23:30:03 +0800 Subject: [PATCH 63/81] Mappings for Bullet3Collision library --- .../bullet/presets/Bullet3Collision.java | 167 ++++++++++++++++++ .../bullet/presets/Bullet3Common.java | 23 ++- bullet/src/main/java9/module-info.java | 1 + 3 files changed, 189 insertions(+), 2 deletions(-) create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java new file mode 100644 index 00000000000..80156635e4f --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java @@ -0,0 +1,167 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +/** + * + * @author Andrey Krainyak + */ +@Properties( + inherit = Bullet3Common.class, + value = { + @Platform( + include = { + "Bullet3Common/b3AlignedObjectArray.h", + "Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h", + "Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h", + "Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h", + "Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h", + "Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h", + "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h", + "Bullet3Collision/NarrowPhaseCollision/b3Config.h", + "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h", + "Bullet3Collision/NarrowPhaseCollision/b3ConvexUtility.h", + "Bullet3Collision/NarrowPhaseCollision/b3CpuNarrowPhase.h", + "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h", + "Bullet3Collision/NarrowPhaseCollision/b3RigidBodyCL.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3ContactConvexConvexSAT.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3FindSeparatingAxis.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3MprPenetration.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h", + "Bullet3Collision/NarrowPhaseCollision/shared/b3UpdateAabbs.h", + }, + link = "Bullet3Collision@.3.20" + ) + }, + target = "org.bytedeco.bullet.Bullet3Collision", + global = "org.bytedeco.bullet.global.Bullet3Collision" +) +public class Bullet3Collision implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + public void map(InfoMap infoMap) { + infoMap + .put(new Info( + "B3_DBVT_BP_PROFILE", + "B3_DBVT_INLINE", + "B3_DBVT_IPOLICY", + "B3_DBVT_USE_TEMPLATE", + "B3_DBVT_VIRTUAL", + "B3_MPR_FABS", + "B3_MPR_SQRT" + ).cppTypes().translate(false)) + + .put(new Info("_b3MprSimplex_t").pointerTypes("b3MprSimplex_t")) + .put(new Info("_b3MprSupport_t").pointerTypes("b3MprSupport_t")) + .put(new Info("b3Aabb_t").pointerTypes("b3Aabb")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3AabbArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3CollidableArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3Contact4DataArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3ConvexPolyhedronDataArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3DbvtProxyArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("sStkNNArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("sStkNPSArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3GpuChildShapeArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3GpuFaceArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3MyFaceArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3RigidBodyDataArray")) + .put(new Info("b3BvhSubtreeInfoData_t").pointerTypes("b3BvhSubtreeInfoData")) + .put(new Info("b3Collidable_t").pointerTypes("b3Collidable")) + .put(new Info("b3Contact4Data_t").pointerTypes("b3Contact4Data")) + .put(new Info("b3ConvexPolyhedronData_t").pointerTypes("b3ConvexPolyhedronData")) + .put(new Info("b3DynamicBvh::sStkNN").pointerTypes("b3DynamicBvh.sStkNN")) + .put(new Info("b3DynamicBvh::sStkNPS").pointerTypes("b3DynamicBvh.sStkNPS")) + .put(new Info("b3GpuChildShape_t").pointerTypes("b3GpuChildShape")) + .put(new Info("b3GpuFace_t").pointerTypes("b3GpuFace")) + .put(new Info("b3InertiaData_t").pointerTypes("b3InertiaData")) + .put(new Info("b3QuantizedBvhNodeData_t").pointerTypes("b3QuantizedBvhNodeData")) + .put(new Info("b3RigidBodyData_t").pointerTypes("b3RigidBodyData")) + + .put(new Info("b3BroadphaseRayCallback").purify(true)) + + .put(new Info( + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3CpuNarrowPhase::getInternalData", + "b3DynamicBvh::extractLeaves", + "b3DynamicBvh::m_rayTestStack" + ).skip()) + ; + } +} diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java index a815de6363e..29092807963 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java @@ -58,6 +58,7 @@ "Bullet3Common/shared/b3Int4.h", "Bullet3Common/shared/b3Quat.h", "Bullet3Common/shared/b3Mat3x3.h", + "Bullet3Common/shared/b3PlatformDefinitions.h", }, link = "Bullet3Common@.3.20" ) @@ -73,14 +74,18 @@ public void map(InfoMap infoMap) { .put(new Info("B3_ATTRIBUTE_ALIGNED16").cppText("#define B3_ATTRIBUTE_ALIGNED16(x) x")) .put(new Info("B3_DECLARE_ALIGNED_ALLOCATOR").cppText("#define B3_DECLARE_ALIGNED_ALLOCATOR()")) .put(new Info("B3_FORCE_INLINE").cppText("#define B3_FORCE_INLINE")) - .put(new Info("__global").cppText("#define __global")) - .put(new Info("__inline").cppText("#define __inline")) .put(new Info("B3_EPSILON").cppTypes("float")) .put(new Info("B3_INFINITY").cppTypes("float")) .put(new Info("B3_LARGE_FLOAT").cppTypes("float")) .put(new Info( + "__global", + "__inline" + ).cppTypes().annotations()) + + .put(new Info( + "B3_STATIC", "b3Cross3", "b3Dot3F4", "b3Float4", @@ -106,12 +111,26 @@ public void map(InfoMap infoMap) { "defined(B3_USE_DOUBLE_PRECISION) || defined(B3_FORCE_DOUBLE_FUNCTIONS)", "defined(B3_USE_DOUBLE_PRECISION)", "defined(B3_USE_SSE) || defined(B3_USE_NEON)", + "defined(B3_USE_SSE)", "defined(B3_USE_SSE_IN_API) && defined(B3_USE_SSE)", "defined(__SPU__) && defined(__CELLOS_LV2__)" ).define(false)) .put(new Info( "__cplusplus" ).define(true)) + + .put(new Info("b3AlignedObjectArray").pointerTypes("b3IntArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3Int4Array")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3Vector3Array")) + + .put(new Info("b3AlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) + + .put(new Info( + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove" + ).skip()) ; } } diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 7aeb1b3e5a2..477bbb9d664 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -7,4 +7,5 @@ exports org.bytedeco.bullet.BulletDynamics; exports org.bytedeco.bullet.BulletSoftBody; exports org.bytedeco.bullet.Bullet3Common; + exports org.bytedeco.bullet.Bullet3Collision; } From bf0a8ee5c59389cf697abeb5847e1cfdc8df2c69 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 3 Mar 2022 23:31:11 +0800 Subject: [PATCH 64/81] Update generated code for bullet's preset --- .../bullet/Bullet3Collision/b3Aabb.java | 44 + .../bullet/Bullet3Collision/b3AabbArray.java | 91 ++ .../b3BroadphaseAabbCallback.java | 23 + .../b3BroadphasePairSortPredicate.java | 42 + .../Bullet3Collision/b3BroadphaseProxy.java | 64 + .../b3BroadphaseRayCallback.java | 27 + .../b3BvhSubtreeInfoData.java | 45 + .../bullet/Bullet3Collision/b3Collidable.java | 42 + .../Bullet3Collision/b3CollidableArray.java | 87 ++ .../b3CompoundOverlappingPair.java | 39 + .../bullet/Bullet3Collision/b3Config.java | 49 + .../bullet/Bullet3Collision/b3Contact4.java | 52 + .../Bullet3Collision/b3Contact4Data.java | 49 + .../Bullet3Collision/b3Contact4DataArray.java | 87 ++ .../b3ConvexPolyhedronData.java | 48 + .../b3ConvexPolyhedronDataArray.java | 87 ++ .../Bullet3Collision/b3ConvexUtility.java | 50 + .../Bullet3Collision/b3CpuNarrowPhase.java | 92 ++ .../bullet/Bullet3Collision/b3DbvtAabbMm.java | 81 ++ .../bullet/Bullet3Collision/b3DbvtNode.java | 43 + .../bullet/Bullet3Collision/b3DbvtProxy.java | 46 + .../Bullet3Collision/b3DbvtProxyArray.java | 87 ++ .../bullet/Bullet3Collision/b3Dispatcher.java | 22 + .../bullet/Bullet3Collision/b3DynamicBvh.java | 315 +++++ .../b3DynamicBvhBroadphase.java | 95 ++ .../Bullet3Collision/b3GpuChildShape.java | 42 + .../b3GpuChildShapeArray.java | 87 ++ .../bullet/Bullet3Collision/b3GpuFace.java | 38 + .../Bullet3Collision/b3GpuFaceArray.java | 87 ++ .../b3HashedOverlappingPairCache.java | 65 + .../Bullet3Collision/b3InertiaData.java | 36 + .../Bullet3Collision/b3MprSimplex_t.java | 38 + .../Bullet3Collision/b3MprSupport_t.java | 40 + .../bullet/Bullet3Collision/b3MyFace.java | 37 + .../Bullet3Collision/b3MyFaceArray.java | 87 ++ .../Bullet3Collision/b3NullPairCache.java | 64 + .../Bullet3Collision/b3OverlapCallback.java | 24 + .../b3OverlapFilterCallback.java | 24 + .../b3OverlappingPairCache.java | 50 + .../b3QuantizedBvhNodeData.java | 44 + .../bullet/Bullet3Collision/b3RayHit.java | 40 + .../bullet/Bullet3Collision/b3RayInfo.java | 36 + .../Bullet3Collision/b3RigidBodyData.java | 43 + .../b3RigidBodyDataArray.java | 87 ++ .../b3SortedOverlappingPairCache.java | 70 + .../bullet/Bullet3Collision/sStkNNArray.java | 87 ++ .../bullet/Bullet3Collision/sStkNPSArray.java | 87 ++ .../bytedeco/bullet/Bullet3Common/MyTest.java | 33 + .../bullet/Bullet3Common/b3Int4Array.java | 85 ++ .../bullet/Bullet3Common/b3IntArray.java | 89 ++ .../bullet/Bullet3Common/b3Vector3Array.java | 85 ++ .../bullet/global/Bullet3Collision.java | 1247 +++++++++++++++++ .../bytedeco/bullet/global/Bullet3Common.java | 39 +- 53 files changed, 4494 insertions(+), 4 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Aabb.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3AabbArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseAabbCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphasePairSortPredicate.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseProxy.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseRayCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BvhSubtreeInfoData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Collidable.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CollidableArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CompoundOverlappingPair.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Config.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4Data.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4DataArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexPolyhedronData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexPolyhedronDataArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexUtility.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CpuNarrowPhase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtAabbMm.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtNode.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtProxy.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtProxyArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Dispatcher.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DynamicBvh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DynamicBvhBroadphase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuChildShape.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuChildShapeArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuFace.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuFaceArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3HashedOverlappingPairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3InertiaData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MprSimplex_t.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MprSupport_t.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MyFace.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MyFaceArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3NullPairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapFilterCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlappingPairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3QuantizedBvhNodeData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayHit.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RigidBodyData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RigidBodyDataArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3SortedOverlappingPairCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNNArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNPSArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/MyTest.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int4Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3IntArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Aabb.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Aabb.java new file mode 100644 index 00000000000..c087da28af7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Aabb.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3Aabb extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Aabb() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Aabb(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Aabb(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Aabb position(long position) { + return (b3Aabb)super.position(position); + } + @Override public b3Aabb getPointer(long i) { + return new b3Aabb((Pointer)this).offsetAddress(i); + } + + public native float m_min(int i); public native b3Aabb m_min(int i, float setter); + @MemberGetter public native FloatPointer m_min(); + public native @ByRef b3Vector3 m_minVec(); public native b3Aabb m_minVec(b3Vector3 setter); + public native int m_minIndices(int i); public native b3Aabb m_minIndices(int i, int setter); + @MemberGetter public native IntPointer m_minIndices(); + public native float m_max(int i); public native b3Aabb m_max(int i, float setter); + @MemberGetter public native FloatPointer m_max(); + public native @ByRef b3Vector3 m_maxVec(); public native b3Aabb m_maxVec(b3Vector3 setter); + public native int m_signedMaxIndices(int i); public native b3Aabb m_signedMaxIndices(int i, int setter); + @MemberGetter public native IntPointer m_signedMaxIndices(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3AabbArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3AabbArray.java new file mode 100644 index 00000000000..d6d536e158c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3AabbArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + //for placement new +// #endif //B3_USE_PLACEMENT_NEW + +/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3AabbArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3AabbArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3AabbArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3AabbArray position(long position) { + return (b3AabbArray)super.position(position); + } + @Override public b3AabbArray getPointer(long i) { + return new b3AabbArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3AabbArray put(@Const @ByRef b3AabbArray other); + public b3AabbArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3AabbArray(@Const @ByRef b3AabbArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3AabbArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3Aabb at(int n); + + public native @ByRef @Name("operator []") b3Aabb get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3Aabb()") b3Aabb fillData); + public native void resize(int newsize); + public native @ByRef b3Aabb expandNonInitializing(); + + public native @ByRef b3Aabb expand(@Const @ByRef(nullValue = "b3Aabb()") b3Aabb fillValue); + public native @ByRef b3Aabb expand(); + + public native void push_back(@Const @ByRef b3Aabb _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3AabbArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseAabbCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseAabbCallback.java new file mode 100644 index 00000000000..0a845dcff64 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseAabbCallback.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3BroadphaseAabbCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BroadphaseAabbCallback(Pointer p) { super(p); } + + public native @Cast("bool") boolean process(@Const b3BroadphaseProxy proxy); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphasePairSortPredicate.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphasePairSortPredicate.java new file mode 100644 index 00000000000..228a8afc81a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphasePairSortPredicate.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/*struct b3BroadphasePair : public b3Int4 +{ + explicit b3BroadphasePair(){} + +}; +*/ + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3BroadphasePairSortPredicate extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3BroadphasePairSortPredicate() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3BroadphasePairSortPredicate(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BroadphasePairSortPredicate(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3BroadphasePairSortPredicate position(long position) { + return (b3BroadphasePairSortPredicate)super.position(position); + } + @Override public b3BroadphasePairSortPredicate getPointer(long i) { + return new b3BroadphasePairSortPredicate((Pointer)this).offsetAddress(i); + } + + public native @Cast("bool") @Name("operator ()") boolean apply(@Cast("const b3BroadphasePair*") @ByRef b3Int4 a, @Cast("const b3BroadphasePair*") @ByRef b3Int4 b); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseProxy.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseProxy.java new file mode 100644 index 00000000000..b3d99b69d0c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseProxy.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +// #if B3_DBVT_BP_PROFILE + +// #endif + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3BroadphaseProxy extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BroadphaseProxy(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3BroadphaseProxy(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3BroadphaseProxy position(long position) { + return (b3BroadphaseProxy)super.position(position); + } + @Override public b3BroadphaseProxy getPointer(long i) { + return new b3BroadphaseProxy((Pointer)this).offsetAddress(i); + } + + + /**optional filtering to cull potential collisions */ + /** enum b3BroadphaseProxy::CollisionFilterGroups */ + public static final int + DefaultFilter = 1, + StaticFilter = 2, + KinematicFilter = 4, + DebrisFilter = 8, + SensorTrigger = 16, + CharacterFilter = 32, + AllFilter = -1; //all bits sets: DefaultFilter | StaticFilter | KinematicFilter | DebrisFilter | SensorTrigger + + //Usually the client b3CollisionObject or Rigidbody class + public native Pointer m_clientObject(); public native b3BroadphaseProxy m_clientObject(Pointer setter); + public native int m_collisionFilterGroup(); public native b3BroadphaseProxy m_collisionFilterGroup(int setter); + public native int m_collisionFilterMask(); public native b3BroadphaseProxy m_collisionFilterMask(int setter); + public native int m_uniqueId(); public native b3BroadphaseProxy m_uniqueId(int setter); //m_uniqueId is introduced for paircache. could get rid of this, by calculating the address offset etc. + + public native @ByRef b3Vector3 m_aabbMin(); public native b3BroadphaseProxy m_aabbMin(b3Vector3 setter); + public native @ByRef b3Vector3 m_aabbMax(); public native b3BroadphaseProxy m_aabbMax(b3Vector3 setter); + + public native int getUid(); + + //used for memory pools + public b3BroadphaseProxy() { super((Pointer)null); allocate(); } + private native void allocate(); + + public b3BroadphaseProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask); } + private native void allocate(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseRayCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseRayCallback.java new file mode 100644 index 00000000000..2bd1ed5f37f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphaseRayCallback.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3BroadphaseRayCallback extends b3BroadphaseAabbCallback { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BroadphaseRayCallback(Pointer p) { super(p); } + + /**added some cached data to accelerate ray-AABB tests */ + public native @ByRef b3Vector3 m_rayDirectionInverse(); public native b3BroadphaseRayCallback m_rayDirectionInverse(b3Vector3 setter); + public native @Cast("unsigned int") int m_signs(int i); public native b3BroadphaseRayCallback m_signs(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer m_signs(); + public native @Cast("b3Scalar") float m_lambda_max(); public native b3BroadphaseRayCallback m_lambda_max(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BvhSubtreeInfoData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BvhSubtreeInfoData.java new file mode 100644 index 00000000000..7b5b91a06de --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BvhSubtreeInfoData.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3BvhSubtreeInfoData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3BvhSubtreeInfoData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3BvhSubtreeInfoData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BvhSubtreeInfoData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3BvhSubtreeInfoData position(long position) { + return (b3BvhSubtreeInfoData)super.position(position); + } + @Override public b3BvhSubtreeInfoData getPointer(long i) { + return new b3BvhSubtreeInfoData((Pointer)this).offsetAddress(i); + } + + //12 bytes + public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native b3BvhSubtreeInfoData m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native b3BvhSubtreeInfoData m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); + //4 bytes, points to the root of the subtree + public native int m_rootNodeIndex(); public native b3BvhSubtreeInfoData m_rootNodeIndex(int setter); + //4 bytes + public native int m_subtreeSize(); public native b3BvhSubtreeInfoData m_subtreeSize(int setter); + public native int m_padding(int i); public native b3BvhSubtreeInfoData m_padding(int i, int setter); + @MemberGetter public native IntPointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Collidable.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Collidable.java new file mode 100644 index 00000000000..4db2b36b340 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Collidable.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3Collidable extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Collidable() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Collidable(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Collidable(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Collidable position(long position) { + return (b3Collidable)super.position(position); + } + @Override public b3Collidable getPointer(long i) { + return new b3Collidable((Pointer)this).offsetAddress(i); + } + + public native int m_numChildShapes(); public native b3Collidable m_numChildShapes(int setter); + public native int m_bvhIndex(); public native b3Collidable m_bvhIndex(int setter); + public native float m_radius(); public native b3Collidable m_radius(float setter); + public native int m_compoundBvhIndex(); public native b3Collidable m_compoundBvhIndex(int setter); + + public native int m_shapeType(); public native b3Collidable m_shapeType(int setter); + public native int m_shapeIndex(); public native b3Collidable m_shapeIndex(int setter); + public native float m_height(); public native b3Collidable m_height(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CollidableArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CollidableArray.java new file mode 100644 index 00000000000..a73f103c3de --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CollidableArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3CollidableArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CollidableArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3CollidableArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3CollidableArray position(long position) { + return (b3CollidableArray)super.position(position); + } + @Override public b3CollidableArray getPointer(long i) { + return new b3CollidableArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3CollidableArray put(@Const @ByRef b3CollidableArray other); + public b3CollidableArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3CollidableArray(@Const @ByRef b3CollidableArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3CollidableArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3Collidable at(int n); + + public native @ByRef @Name("operator []") b3Collidable get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3Collidable()") b3Collidable fillData); + public native void resize(int newsize); + public native @ByRef b3Collidable expandNonInitializing(); + + public native @ByRef b3Collidable expand(@Const @ByRef(nullValue = "b3Collidable()") b3Collidable fillValue); + public native @ByRef b3Collidable expand(); + + public native void push_back(@Const @ByRef b3Collidable _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3CollidableArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CompoundOverlappingPair.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CompoundOverlappingPair.java new file mode 100644 index 00000000000..6380e195e6b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CompoundOverlappingPair.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3CompoundOverlappingPair extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3CompoundOverlappingPair() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3CompoundOverlappingPair(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CompoundOverlappingPair(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3CompoundOverlappingPair position(long position) { + return (b3CompoundOverlappingPair)super.position(position); + } + @Override public b3CompoundOverlappingPair getPointer(long i) { + return new b3CompoundOverlappingPair((Pointer)this).offsetAddress(i); + } + + public native int m_bodyIndexA(); public native b3CompoundOverlappingPair m_bodyIndexA(int setter); + public native int m_bodyIndexB(); public native b3CompoundOverlappingPair m_bodyIndexB(int setter); + // int m_pairType; + public native int m_childShapeIndexA(); public native b3CompoundOverlappingPair m_childShapeIndexA(int setter); + public native int m_childShapeIndexB(); public native b3CompoundOverlappingPair m_childShapeIndexB(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Config.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Config.java new file mode 100644 index 00000000000..0115e255e8c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Config.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3Config extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Config(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Config(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Config position(long position) { + return (b3Config)super.position(position); + } + @Override public b3Config getPointer(long i) { + return new b3Config((Pointer)this).offsetAddress(i); + } + + public native int m_maxConvexBodies(); public native b3Config m_maxConvexBodies(int setter); + public native int m_maxConvexShapes(); public native b3Config m_maxConvexShapes(int setter); + public native int m_maxBroadphasePairs(); public native b3Config m_maxBroadphasePairs(int setter); + public native int m_maxContactCapacity(); public native b3Config m_maxContactCapacity(int setter); + public native int m_compoundPairCapacity(); public native b3Config m_compoundPairCapacity(int setter); + + public native int m_maxVerticesPerFace(); public native b3Config m_maxVerticesPerFace(int setter); + public native int m_maxFacesPerShape(); public native b3Config m_maxFacesPerShape(int setter); + public native int m_maxConvexVertices(); public native b3Config m_maxConvexVertices(int setter); + public native int m_maxConvexIndices(); public native b3Config m_maxConvexIndices(int setter); + public native int m_maxConvexUniqueEdges(); public native b3Config m_maxConvexUniqueEdges(int setter); + + public native int m_maxCompoundChildShapes(); public native b3Config m_maxCompoundChildShapes(int setter); + + public native int m_maxTriConvexPairCapacity(); public native b3Config m_maxTriConvexPairCapacity(int setter); + + public b3Config() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4.java new file mode 100644 index 00000000000..0ae15e68fca --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3Contact4 extends b3Contact4Data { + static { Loader.load(); } + /** Default native constructor. */ + public b3Contact4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Contact4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Contact4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Contact4 position(long position) { + return (b3Contact4)super.position(position); + } + @Override public b3Contact4 getPointer(long i) { + return new b3Contact4((Pointer)this).offsetAddress(i); + } + + + public native int getBodyA(); + public native int getBodyB(); + public native @Cast("bool") boolean isBodyAFixed(); + public native @Cast("bool") boolean isBodyBFixed(); + // todo. make it safer + public native @ByRef IntPointer getBatchIdx(); + public native float getRestituitionCoeff(); + public native void setRestituitionCoeff(float c); + public native float getFrictionCoeff(); + public native void setFrictionCoeff(float c); + + //float& getNPoints() { return m_worldNormal[3]; } + public native int getNPoints(); + + public native float getPenetration(int idx); + + public native @Cast("bool") boolean isInvalid(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4Data.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4Data.java new file mode 100644 index 00000000000..15278c16719 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4Data.java @@ -0,0 +1,49 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3Contact4Data extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Contact4Data() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Contact4Data(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Contact4Data(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Contact4Data position(long position) { + return (b3Contact4Data)super.position(position); + } + @Override public b3Contact4Data getPointer(long i) { + return new b3Contact4Data((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_worldPosB(int i); public native b3Contact4Data m_worldPosB(int i, b3Vector3 setter); + @MemberGetter public native b3Vector3 m_worldPosB(); + // b3Float4 m_localPosA[4]; + // b3Float4 m_localPosB[4]; + public native @ByRef b3Vector3 m_worldNormalOnB(); public native b3Contact4Data m_worldNormalOnB(b3Vector3 setter); // w: m_nPoints + public native @Cast("unsigned short") short m_restituitionCoeffCmp(); public native b3Contact4Data m_restituitionCoeffCmp(short setter); + public native @Cast("unsigned short") short m_frictionCoeffCmp(); public native b3Contact4Data m_frictionCoeffCmp(short setter); + public native int m_batchIdx(); public native b3Contact4Data m_batchIdx(int setter); + public native int m_bodyAPtrAndSignBit(); public native b3Contact4Data m_bodyAPtrAndSignBit(int setter); //x:m_bodyAPtr, y:m_bodyBPtr + public native int m_bodyBPtrAndSignBit(); public native b3Contact4Data m_bodyBPtrAndSignBit(int setter); + + public native int m_childIndexA(); public native b3Contact4Data m_childIndexA(int setter); + public native int m_childIndexB(); public native b3Contact4Data m_childIndexB(int setter); + public native int m_unused1(); public native b3Contact4Data m_unused1(int setter); + public native int m_unused2(); public native b3Contact4Data m_unused2(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4DataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4DataArray.java new file mode 100644 index 00000000000..2c1b6e88629 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Contact4DataArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3Contact4DataArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Contact4DataArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Contact4DataArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Contact4DataArray position(long position) { + return (b3Contact4DataArray)super.position(position); + } + @Override public b3Contact4DataArray getPointer(long i) { + return new b3Contact4DataArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3Contact4DataArray put(@Const @ByRef b3Contact4DataArray other); + public b3Contact4DataArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3Contact4DataArray(@Const @ByRef b3Contact4DataArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3Contact4DataArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3Contact4Data at(int n); + + public native @ByRef @Name("operator []") b3Contact4Data get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3Contact4Data()") b3Contact4Data fillData); + public native void resize(int newsize); + public native @ByRef b3Contact4Data expandNonInitializing(); + + public native @ByRef b3Contact4Data expand(@Const @ByRef(nullValue = "b3Contact4Data()") b3Contact4Data fillValue); + public native @ByRef b3Contact4Data expand(); + + public native void push_back(@Const @ByRef b3Contact4Data _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3Contact4DataArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexPolyhedronData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexPolyhedronData.java new file mode 100644 index 00000000000..ccf38426bc1 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexPolyhedronData.java @@ -0,0 +1,48 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3ConvexPolyhedronData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ConvexPolyhedronData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConvexPolyhedronData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConvexPolyhedronData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ConvexPolyhedronData position(long position) { + return (b3ConvexPolyhedronData)super.position(position); + } + @Override public b3ConvexPolyhedronData getPointer(long i) { + return new b3ConvexPolyhedronData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_localCenter(); public native b3ConvexPolyhedronData m_localCenter(b3Vector3 setter); + public native @ByRef b3Vector3 m_extents(); public native b3ConvexPolyhedronData m_extents(b3Vector3 setter); + public native @ByRef b3Vector3 mC(); public native b3ConvexPolyhedronData mC(b3Vector3 setter); + public native @ByRef b3Vector3 mE(); public native b3ConvexPolyhedronData mE(b3Vector3 setter); + + public native float m_radius(); public native b3ConvexPolyhedronData m_radius(float setter); + public native int m_faceOffset(); public native b3ConvexPolyhedronData m_faceOffset(int setter); + public native int m_numFaces(); public native b3ConvexPolyhedronData m_numFaces(int setter); + public native int m_numVertices(); public native b3ConvexPolyhedronData m_numVertices(int setter); + + public native int m_vertexOffset(); public native b3ConvexPolyhedronData m_vertexOffset(int setter); + public native int m_uniqueEdgesOffset(); public native b3ConvexPolyhedronData m_uniqueEdgesOffset(int setter); + public native int m_numUniqueEdges(); public native b3ConvexPolyhedronData m_numUniqueEdges(int setter); + public native int m_unused(); public native b3ConvexPolyhedronData m_unused(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexPolyhedronDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexPolyhedronDataArray.java new file mode 100644 index 00000000000..d38e96fab07 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexPolyhedronDataArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3ConvexPolyhedronDataArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConvexPolyhedronDataArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConvexPolyhedronDataArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3ConvexPolyhedronDataArray position(long position) { + return (b3ConvexPolyhedronDataArray)super.position(position); + } + @Override public b3ConvexPolyhedronDataArray getPointer(long i) { + return new b3ConvexPolyhedronDataArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3ConvexPolyhedronDataArray put(@Const @ByRef b3ConvexPolyhedronDataArray other); + public b3ConvexPolyhedronDataArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3ConvexPolyhedronDataArray(@Const @ByRef b3ConvexPolyhedronDataArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3ConvexPolyhedronDataArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3ConvexPolyhedronData at(int n); + + public native @ByRef @Name("operator []") b3ConvexPolyhedronData get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3ConvexPolyhedronData()") b3ConvexPolyhedronData fillData); + public native void resize(int newsize); + public native @ByRef b3ConvexPolyhedronData expandNonInitializing(); + + public native @ByRef b3ConvexPolyhedronData expand(@Const @ByRef(nullValue = "b3ConvexPolyhedronData()") b3ConvexPolyhedronData fillValue); + public native @ByRef b3ConvexPolyhedronData expand(); + + public native void push_back(@Const @ByRef b3ConvexPolyhedronData _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3ConvexPolyhedronDataArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexUtility.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexUtility.java new file mode 100644 index 00000000000..df1b3838c1d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexUtility.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3ConvexUtility extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConvexUtility(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConvexUtility(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3ConvexUtility position(long position) { + return (b3ConvexUtility)super.position(position); + } + @Override public b3ConvexUtility getPointer(long i) { + return new b3ConvexUtility((Pointer)this).offsetAddress(i); + } + + + public native @ByRef b3Vector3 m_localCenter(); public native b3ConvexUtility m_localCenter(b3Vector3 setter); + public native @ByRef b3Vector3 m_extents(); public native b3ConvexUtility m_extents(b3Vector3 setter); + public native @ByRef b3Vector3 mC(); public native b3ConvexUtility mC(b3Vector3 setter); + public native @ByRef b3Vector3 mE(); public native b3ConvexUtility mE(b3Vector3 setter); + public native @Cast("b3Scalar") float m_radius(); public native b3ConvexUtility m_radius(float setter); + + public native @ByRef b3Vector3Array m_vertices(); public native b3ConvexUtility m_vertices(b3Vector3Array setter); + public native @ByRef b3MyFaceArray m_faces(); public native b3ConvexUtility m_faces(b3MyFaceArray setter); + public native @ByRef b3Vector3Array m_uniqueEdges(); public native b3ConvexUtility m_uniqueEdges(b3Vector3Array setter); + + public b3ConvexUtility() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native @Cast("bool") boolean initializePolyhedralFeatures(@Const b3Vector3 orgVertices, int numVertices, @Cast("bool") boolean mergeCoplanarTriangles/*=true*/); + public native @Cast("bool") boolean initializePolyhedralFeatures(@Const b3Vector3 orgVertices, int numVertices); + + public native void initialize(); + public native @Cast("bool") boolean testContainment(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CpuNarrowPhase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CpuNarrowPhase.java new file mode 100644 index 00000000000..ea38c4d61ad --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CpuNarrowPhase.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3CpuNarrowPhase extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CpuNarrowPhase(Pointer p) { super(p); } + + public b3CpuNarrowPhase(@Const @ByRef b3Config config) { super((Pointer)null); allocate(config); } + private native void allocate(@Const @ByRef b3Config config); + + public native int registerSphereShape(float radius); + public native int registerPlaneShape(@Const @ByRef b3Vector3 planeNormal, float planeConstant); + + public native int registerCompoundShape(b3GpuChildShapeArray childShapes); + public native int registerFace(@Const @ByRef b3Vector3 faceNormal, float faceConstant); + + public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const FloatPointer scaling); + public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const FloatBuffer scaling); + public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const float[] scaling); + + //do they need to be merged? + + public native int registerConvexHullShape(b3ConvexUtility utilPtr); + public native int registerConvexHullShape(@Const FloatPointer vertices, int strideInBytes, int numVertices, @Const FloatPointer scaling); + public native int registerConvexHullShape(@Const FloatBuffer vertices, int strideInBytes, int numVertices, @Const FloatBuffer scaling); + public native int registerConvexHullShape(@Const float[] vertices, int strideInBytes, int numVertices, @Const float[] scaling); + + //int registerRigidBody(int collidableIndex, float mass, const float* position, const float* orientation, const float* aabbMin, const float* aabbMax,bool writeToGpu); + public native void setObjectTransform(@Const FloatPointer _position, @Const FloatPointer orientation, int bodyIndex); + public native void setObjectTransform(@Const FloatBuffer _position, @Const FloatBuffer orientation, int bodyIndex); + public native void setObjectTransform(@Const float[] _position, @Const float[] orientation, int bodyIndex); + + public native void writeAllBodiesToGpu(); + public native void reset(); + public native void readbackAllBodiesToCpu(); + public native @Cast("bool") boolean getObjectTransformFromCpu(FloatPointer _position, FloatPointer orientation, int bodyIndex); + public native @Cast("bool") boolean getObjectTransformFromCpu(FloatBuffer _position, FloatBuffer orientation, int bodyIndex); + public native @Cast("bool") boolean getObjectTransformFromCpu(float[] _position, float[] orientation, int bodyIndex); + + public native void setObjectTransformCpu(FloatPointer _position, FloatPointer orientation, int bodyIndex); + public native void setObjectTransformCpu(FloatBuffer _position, FloatBuffer orientation, int bodyIndex); + public native void setObjectTransformCpu(float[] _position, float[] orientation, int bodyIndex); + public native void setObjectVelocityCpu(FloatPointer linVel, FloatPointer angVel, int bodyIndex); + public native void setObjectVelocityCpu(FloatBuffer linVel, FloatBuffer angVel, int bodyIndex); + public native void setObjectVelocityCpu(float[] linVel, float[] angVel, int bodyIndex); + + //virtual void computeContacts(cl_mem broadphasePairs, int numBroadphasePairs, cl_mem aabbsWorldSpace, int numObjects); + public native void computeContacts(@ByRef b3Int4Array pairs, @ByRef b3AabbArray aabbsWorldSpace, @ByRef b3RigidBodyDataArray bodies); + + public native @Const b3RigidBodyData getBodiesCpu(); + //struct b3RigidBodyData* getBodiesCpu(); + + public native int getNumBodiesGpu(); + + public native int getNumBodyInertiasGpu(); + + public native @Const b3Collidable getCollidablesCpu(); + public native int getNumCollidablesGpu(); + + /*const struct b3Contact4* getContactsCPU() const; + + + int getNumContactsGpu() const; + */ + + public native @Const @ByRef b3Contact4DataArray getContacts(); + + public native int getNumRigidBodies(); + + public native int allocateCollidable(); + + public native int getStatic0Index(); + public native @ByRef b3Collidable getCollidableCpu(int collidableIndex); + + + + public native @Const @ByRef b3Aabb getLocalSpaceAabb(int collidableIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtAabbMm.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtAabbMm.java new file mode 100644 index 00000000000..8b53616ea7b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtAabbMm.java @@ -0,0 +1,81 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +// #endif + +// #ifndef B3_DBVT_USE_MEMMOVE +// #endif + +// #ifndef B3_DBVT_ENABLE_BENCHMARK +// #endif + +// #ifndef B3_DBVT_SELECT_IMPL +// #endif + +// #ifndef B3_DBVT_MERGE_IMPL +// #endif + +// #ifndef B3_DBVT_INT0_IMPL +// #endif + +// +// Defaults volumes +// + +/* b3DbvtAabbMm */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3DbvtAabbMm extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3DbvtAabbMm() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3DbvtAabbMm(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3DbvtAabbMm(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3DbvtAabbMm position(long position) { + return (b3DbvtAabbMm)super.position(position); + } + @Override public b3DbvtAabbMm getPointer(long i) { + return new b3DbvtAabbMm((Pointer)this).offsetAddress(i); + } + + public native @ByVal b3Vector3 Center(); + public native @ByVal b3Vector3 Lengths(); + public native @ByVal b3Vector3 Extents(); + public native @Const @ByRef b3Vector3 Mins(); + public native @Const @ByRef b3Vector3 Maxs(); + public static native @ByVal b3DbvtAabbMm FromCE(@Const @ByRef b3Vector3 c, @Const @ByRef b3Vector3 e); + public static native @ByVal b3DbvtAabbMm FromCR(@Const @ByRef b3Vector3 c, @Cast("b3Scalar") float r); + public static native @ByVal b3DbvtAabbMm FromMM(@Const @ByRef b3Vector3 mi, @Const @ByRef b3Vector3 mx); + public static native @ByVal b3DbvtAabbMm FromPoints(@Const b3Vector3 pts, int n); + public static native @ByVal b3DbvtAabbMm FromPoints(@Cast("const b3Vector3**") PointerPointer ppts, int n); + public native void Expand(@Const @ByRef b3Vector3 e); + public native void SignedExpand(@Const @ByRef b3Vector3 e); + public native @Cast("bool") boolean Contain(@Const @ByRef b3DbvtAabbMm a); + public native int Classify(@Const @ByRef b3Vector3 n, @Cast("b3Scalar") float o, int s); + public native @Cast("b3Scalar") float ProjectMinimum(@Const @ByRef b3Vector3 v, @Cast("unsigned") int signs); + + + + + + + + + + public native @ByRef b3Vector3 tMins(); + public native @ByRef b3Vector3 tMaxs(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtNode.java new file mode 100644 index 00000000000..48d8abf0ae5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtNode.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/* b3DbvtNode */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3DbvtNode extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3DbvtNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3DbvtNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3DbvtNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3DbvtNode position(long position) { + return (b3DbvtNode)super.position(position); + } + @Override public b3DbvtNode getPointer(long i) { + return new b3DbvtNode((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Cast("b3DbvtVolume*") b3DbvtAabbMm volume(); public native b3DbvtNode volume(b3DbvtAabbMm setter); + public native b3DbvtNode parent(); public native b3DbvtNode parent(b3DbvtNode setter); + public native @Cast("bool") boolean isleaf(); + public native @Cast("bool") boolean isinternal(); + public native b3DbvtNode childs(int i); public native b3DbvtNode childs(int i, b3DbvtNode setter); + @MemberGetter public native @Cast("b3DbvtNode**") PointerPointer childs(); + public native Pointer data(); public native b3DbvtNode data(Pointer setter); + public native int dataAsInt(); public native b3DbvtNode dataAsInt(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtProxy.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtProxy.java new file mode 100644 index 00000000000..9e18d0d2ae8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtProxy.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +// +// b3DbvtProxy +// +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3DbvtProxy extends b3BroadphaseProxy { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3DbvtProxy(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3DbvtProxy(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3DbvtProxy position(long position) { + return (b3DbvtProxy)super.position(position); + } + @Override public b3DbvtProxy getPointer(long i) { + return new b3DbvtProxy((Pointer)this).offsetAddress(i); + } + + /* Fields */ + //b3DbvtAabbMm aabb; + public native b3DbvtNode leaf(); public native b3DbvtProxy leaf(b3DbvtNode setter); + public native b3DbvtProxy links(int i); public native b3DbvtProxy links(int i, b3DbvtProxy setter); + @MemberGetter public native @Cast("b3DbvtProxy**") PointerPointer links(); + public native int stage(); public native b3DbvtProxy stage(int setter); + /* ctor */ + + public b3DbvtProxy() { super((Pointer)null); allocate(); } + private native void allocate(); + public b3DbvtProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask) { super((Pointer)null); allocate(aabbMin, aabbMax, userPtr, collisionFilterGroup, collisionFilterMask); } + private native void allocate(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtProxyArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtProxyArray.java new file mode 100644 index 00000000000..becb867497a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DbvtProxyArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3DbvtProxyArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3DbvtProxyArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3DbvtProxyArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3DbvtProxyArray position(long position) { + return (b3DbvtProxyArray)super.position(position); + } + @Override public b3DbvtProxyArray getPointer(long i) { + return new b3DbvtProxyArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3DbvtProxyArray put(@Const @ByRef b3DbvtProxyArray other); + public b3DbvtProxyArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3DbvtProxyArray(@Const @ByRef b3DbvtProxyArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3DbvtProxyArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3DbvtProxy at(int n); + + public native @ByRef @Name("operator []") b3DbvtProxy get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3DbvtProxy()") b3DbvtProxy fillData); + public native void resize(int newsize); + public native @ByRef b3DbvtProxy expandNonInitializing(); + + public native @ByRef b3DbvtProxy expand(@Const @ByRef(nullValue = "b3DbvtProxy()") b3DbvtProxy fillValue); + public native @ByRef b3DbvtProxy expand(); + + public native void push_back(@Const @ByRef b3DbvtProxy _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3DbvtProxyArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Dispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Dispatcher.java new file mode 100644 index 00000000000..1a371bf85d9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3Dispatcher.java @@ -0,0 +1,22 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3Dispatcher extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3Dispatcher() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Dispatcher(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DynamicBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DynamicBvh.java new file mode 100644 index 00000000000..3c5e7a39682 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DynamicBvh.java @@ -0,0 +1,315 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/**The b3DynamicBvh class implements a fast dynamic bounding volume tree based on axis aligned bounding boxes (aabb tree). + * This b3DynamicBvh is used for soft body collision detection and for the b3DynamicBvhBroadphase. It has a fast insert, remove and update of nodes. + * Unlike the b3QuantizedBvh, nodes can be dynamically moved around, which allows for change in topology of the underlying data structure. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3DynamicBvh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3DynamicBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3DynamicBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3DynamicBvh position(long position) { + return (b3DynamicBvh)super.position(position); + } + @Override public b3DynamicBvh getPointer(long i) { + return new b3DynamicBvh((Pointer)this).offsetAddress(i); + } + + /* Stack element */ + @NoOffset public static class sStkNN extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkNN(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sStkNN(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public sStkNN position(long position) { + return (sStkNN)super.position(position); + } + @Override public sStkNN getPointer(long i) { + return new sStkNN((Pointer)this).offsetAddress(i); + } + + public native @Const b3DbvtNode a(); public native sStkNN a(b3DbvtNode setter); + public native @Const b3DbvtNode b(); public native sStkNN b(b3DbvtNode setter); + public sStkNN() { super((Pointer)null); allocate(); } + private native void allocate(); + public sStkNN(@Const b3DbvtNode na, @Const b3DbvtNode nb) { super((Pointer)null); allocate(na, nb); } + private native void allocate(@Const b3DbvtNode na, @Const b3DbvtNode nb); + } + @NoOffset public static class sStkNP extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkNP(Pointer p) { super(p); } + + public native @Const b3DbvtNode node(); public native sStkNP node(b3DbvtNode setter); + public native int mask(); public native sStkNP mask(int setter); + public sStkNP(@Const b3DbvtNode n, @Cast("unsigned") int m) { super((Pointer)null); allocate(n, m); } + private native void allocate(@Const b3DbvtNode n, @Cast("unsigned") int m); + } + @NoOffset public static class sStkNPS extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkNPS(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sStkNPS(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public sStkNPS position(long position) { + return (sStkNPS)super.position(position); + } + @Override public sStkNPS getPointer(long i) { + return new sStkNPS((Pointer)this).offsetAddress(i); + } + + public native @Const b3DbvtNode node(); public native sStkNPS node(b3DbvtNode setter); + public native int mask(); public native sStkNPS mask(int setter); + public native @Cast("b3Scalar") float value(); public native sStkNPS value(float setter); + public sStkNPS() { super((Pointer)null); allocate(); } + private native void allocate(); + public sStkNPS(@Const b3DbvtNode n, @Cast("unsigned") int m, @Cast("b3Scalar") float v) { super((Pointer)null); allocate(n, m, v); } + private native void allocate(@Const b3DbvtNode n, @Cast("unsigned") int m, @Cast("b3Scalar") float v); + } + @NoOffset public static class sStkCLN extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkCLN(Pointer p) { super(p); } + + public native @Const b3DbvtNode node(); public native sStkCLN node(b3DbvtNode setter); + public native b3DbvtNode parent(); public native sStkCLN parent(b3DbvtNode setter); + public sStkCLN(@Const b3DbvtNode n, b3DbvtNode p) { super((Pointer)null); allocate(n, p); } + private native void allocate(@Const b3DbvtNode n, b3DbvtNode p); + } + // Policies/Interfaces + + /* ICollide */ + public static class ICollide extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public ICollide() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public ICollide(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ICollide(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public ICollide position(long position) { + return (ICollide)super.position(position); + } + @Override public ICollide getPointer(long i) { + return new ICollide((Pointer)this).offsetAddress(i); + } + + public native void Process(@Const b3DbvtNode arg0, @Const b3DbvtNode arg1); + public native void Process(@Const b3DbvtNode arg0); + public native void Process(@Const b3DbvtNode n, @Cast("b3Scalar") float arg1); + public native @Cast("bool") boolean Descent(@Const b3DbvtNode arg0); + public native @Cast("bool") boolean AllLeaves(@Const b3DbvtNode arg0); + } + /* IWriter */ + public static class IWriter extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IWriter(Pointer p) { super(p); } + + public native void Prepare(@Const b3DbvtNode root, int numnodes); + public native void WriteNode(@Const b3DbvtNode arg0, int index, int parent, int child0, int child1); + public native void WriteLeaf(@Const b3DbvtNode arg0, int index, int parent); + } + /* IClone */ + public static class IClone extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public IClone() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public IClone(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public IClone(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public IClone position(long position) { + return (IClone)super.position(position); + } + @Override public IClone getPointer(long i) { + return new IClone((Pointer)this).offsetAddress(i); + } + + public native void CloneLeaf(b3DbvtNode arg0); + } + + // Constants + /** enum b3DynamicBvh:: */ + public static final int + B3_SIMPLE_STACKSIZE = 64, + B3_DOUBLE_STACKSIZE = B3_SIMPLE_STACKSIZE * 2; + + // Fields + public native b3DbvtNode m_root(); public native b3DynamicBvh m_root(b3DbvtNode setter); + public native b3DbvtNode m_free(); public native b3DynamicBvh m_free(b3DbvtNode setter); + public native int m_lkhd(); public native b3DynamicBvh m_lkhd(int setter); + public native int m_leaves(); public native b3DynamicBvh m_leaves(int setter); + public native @Cast("unsigned") int m_opath(); public native b3DynamicBvh m_opath(int setter); + + public native @ByRef sStkNNArray m_stkStack(); public native b3DynamicBvh m_stkStack(sStkNNArray setter); + + + // Methods + public b3DynamicBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + public native void clear(); + public native @Cast("bool") boolean empty(); + public native void optimizeBottomUp(); + public native void optimizeTopDown(int bu_treshold/*=128*/); + public native void optimizeTopDown(); + public native void optimizeIncremental(int passes); + public native b3DbvtNode insert(@Cast("const b3DbvtVolume*") @ByRef b3DbvtAabbMm box, Pointer data); + public native void update(b3DbvtNode leaf, int lookahead/*=-1*/); + public native void update(b3DbvtNode leaf); + public native void update(b3DbvtNode leaf, @Cast("b3DbvtVolume*") @ByRef b3DbvtAabbMm volume); + public native @Cast("bool") boolean update(b3DbvtNode leaf, @Cast("b3DbvtVolume*") @ByRef b3DbvtAabbMm volume, @Const @ByRef b3Vector3 velocity, @Cast("b3Scalar") float margin); + public native @Cast("bool") boolean update(b3DbvtNode leaf, @Cast("b3DbvtVolume*") @ByRef b3DbvtAabbMm volume, @Const @ByRef b3Vector3 velocity); + public native @Cast("bool") boolean update(b3DbvtNode leaf, @Cast("b3DbvtVolume*") @ByRef b3DbvtAabbMm volume, @Cast("b3Scalar") float margin); + public native void remove(b3DbvtNode leaf); + public native void write(IWriter iwriter); + public native void clone(@ByRef b3DynamicBvh dest, IClone iclone/*=0*/); + public native void clone(@ByRef b3DynamicBvh dest); + public static native int maxdepth(@Const b3DbvtNode node); + public static native int countLeaves(@Const b3DbvtNode node); + +// #if B3_DBVT_ENABLE_BENCHMARK + public static native void benchmark(); +// #else +// #endif + // B3_DBVT_IPOLICY must support ICollide policy/interface + public static native void enumNodes(@Const b3DbvtNode root, + @ByRef ICollide policy); + public static native void enumLeaves(@Const b3DbvtNode root, + @ByRef ICollide policy); + public native void collideTT(@Const b3DbvtNode root0, + @Const b3DbvtNode root1, + @ByRef ICollide policy); + + public native void collideTTpersistentStack(@Const b3DbvtNode root0, + @Const b3DbvtNode root1, + @ByRef ICollide policy); +// #if 0 +// #endif + + public native void collideTV(@Const b3DbvtNode root, + @Cast("const b3DbvtVolume*") @ByRef b3DbvtAabbMm volume, + @ByRef ICollide policy); + /**rayTest is a re-entrant ray test, and can be called in parallel as long as the b3AlignedAlloc is thread-safe (uses locking etc) + * rayTest is slower than rayTestInternal, because it builds a local stack, using memory allocations, and it recomputes signs/rayDirectionInverses each time */ + public static native void rayTest(@Const b3DbvtNode root, + @Const @ByRef b3Vector3 rayFrom, + @Const @ByRef b3Vector3 rayTo, + @ByRef ICollide policy); + /**rayTestInternal is faster than rayTest, because it uses a persistent stack (to reduce dynamic memory allocations to a minimum) and it uses precomputed signs/rayInverseDirections + * rayTestInternal is used by b3DynamicBvhBroadphase to accelerate world ray casts */ + public native void rayTestInternal(@Const b3DbvtNode root, + @Const @ByRef b3Vector3 rayFrom, + @Const @ByRef b3Vector3 rayTo, + @Const @ByRef b3Vector3 rayDirectionInverse, + @Cast("unsigned int*") IntPointer signs, + @Cast("b3Scalar") float lambda_max, + @Const @ByRef b3Vector3 aabbMin, + @Const @ByRef b3Vector3 aabbMax, + @ByRef ICollide policy); + public native void rayTestInternal(@Const b3DbvtNode root, + @Const @ByRef b3Vector3 rayFrom, + @Const @ByRef b3Vector3 rayTo, + @Const @ByRef b3Vector3 rayDirectionInverse, + @Cast("unsigned int*") IntBuffer signs, + @Cast("b3Scalar") float lambda_max, + @Const @ByRef b3Vector3 aabbMin, + @Const @ByRef b3Vector3 aabbMax, + @ByRef ICollide policy); + public native void rayTestInternal(@Const b3DbvtNode root, + @Const @ByRef b3Vector3 rayFrom, + @Const @ByRef b3Vector3 rayTo, + @Const @ByRef b3Vector3 rayDirectionInverse, + @Cast("unsigned int*") int[] signs, + @Cast("b3Scalar") float lambda_max, + @Const @ByRef b3Vector3 aabbMin, + @Const @ByRef b3Vector3 aabbMax, + @ByRef ICollide policy); + + public static native void collideKDOP(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") FloatPointer offsets, + int count, + @ByRef ICollide policy); + public static native void collideKDOP(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") FloatBuffer offsets, + int count, + @ByRef ICollide policy); + public static native void collideKDOP(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") float[] offsets, + int count, + @ByRef ICollide policy); + public static native void collideOCL(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") FloatPointer offsets, + @Const @ByRef b3Vector3 sortaxis, + int count, + @ByRef ICollide policy, + @Cast("bool") boolean fullsort/*=true*/); + public static native void collideOCL(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") FloatPointer offsets, + @Const @ByRef b3Vector3 sortaxis, + int count, + @ByRef ICollide policy); + public static native void collideOCL(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") FloatBuffer offsets, + @Const @ByRef b3Vector3 sortaxis, + int count, + @ByRef ICollide policy, + @Cast("bool") boolean fullsort/*=true*/); + public static native void collideOCL(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") FloatBuffer offsets, + @Const @ByRef b3Vector3 sortaxis, + int count, + @ByRef ICollide policy); + public static native void collideOCL(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") float[] offsets, + @Const @ByRef b3Vector3 sortaxis, + int count, + @ByRef ICollide policy, + @Cast("bool") boolean fullsort/*=true*/); + public static native void collideOCL(@Const b3DbvtNode root, + @Const b3Vector3 normals, + @Cast("const b3Scalar*") float[] offsets, + @Const @ByRef b3Vector3 sortaxis, + int count, + @ByRef ICollide policy); + public static native void collideTU(@Const b3DbvtNode root, + @ByRef ICollide policy); + // Helpers + public static native int nearest(@Const IntPointer i, @Const sStkNPS a, @Cast("b3Scalar") float v, int l, int h); + public static native int nearest(@Const IntBuffer i, @Const sStkNPS a, @Cast("b3Scalar") float v, int l, int h); + public static native int nearest(@Const int[] i, @Const sStkNPS a, @Cast("b3Scalar") float v, int l, int h); + public static native @Name("allocate") int _allocate(@ByRef b3IntArray ifree, + @ByRef sStkNPSArray stock, + @Const @ByRef sStkNPS value); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DynamicBvhBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DynamicBvhBroadphase.java new file mode 100644 index 00000000000..ae6991dfe53 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3DynamicBvhBroadphase.java @@ -0,0 +1,95 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/**The b3DynamicBvhBroadphase implements a broadphase using two dynamic AABB bounding volume hierarchies/trees (see b3DynamicBvh). + * One tree is used for static/non-moving objects, and another tree is used for dynamic objects. Objects can move from one tree to the other. + * This is a very fast broadphase, especially for very dynamic worlds where many objects are moving. Its insert/add and remove of objects is generally faster than the sweep and prune broadphases b3AxisSweep3 and b332BitAxisSweep3. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3DynamicBvhBroadphase extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3DynamicBvhBroadphase(Pointer p) { super(p); } + + /* Config */ + /** enum b3DynamicBvhBroadphase:: */ + public static final int + DYNAMIC_SET = 0, /* Dynamic set index */ + FIXED_SET = 1, /* Fixed set index */ + STAGECOUNT = 2; /* Number of stages */ + /* Fields */ + public native @ByRef b3DynamicBvh m_sets(int i); public native b3DynamicBvhBroadphase m_sets(int i, b3DynamicBvh setter); + @MemberGetter public native b3DynamicBvh m_sets(); // Dbvt sets + public native b3DbvtProxy m_stageRoots(int i); public native b3DynamicBvhBroadphase m_stageRoots(int i, b3DbvtProxy setter); + @MemberGetter public native @Cast("b3DbvtProxy**") PointerPointer m_stageRoots(); // Stages list + + public native @ByRef b3DbvtProxyArray m_proxies(); public native b3DynamicBvhBroadphase m_proxies(b3DbvtProxyArray setter); + public native b3OverlappingPairCache m_paircache(); public native b3DynamicBvhBroadphase m_paircache(b3OverlappingPairCache setter); // Pair cache + public native @Cast("b3Scalar") float m_prediction(); public native b3DynamicBvhBroadphase m_prediction(float setter); // Velocity prediction + public native int m_stageCurrent(); public native b3DynamicBvhBroadphase m_stageCurrent(int setter); // Current stage + public native int m_fupdates(); public native b3DynamicBvhBroadphase m_fupdates(int setter); // % of fixed updates per frame + public native int m_dupdates(); public native b3DynamicBvhBroadphase m_dupdates(int setter); // % of dynamic updates per frame + public native int m_cupdates(); public native b3DynamicBvhBroadphase m_cupdates(int setter); // % of cleanup updates per frame + public native int m_newpairs(); public native b3DynamicBvhBroadphase m_newpairs(int setter); // Number of pairs created + public native int m_fixedleft(); public native b3DynamicBvhBroadphase m_fixedleft(int setter); // Fixed optimization left + public native @Cast("unsigned") int m_updates_call(); public native b3DynamicBvhBroadphase m_updates_call(int setter); // Number of updates call + public native @Cast("unsigned") int m_updates_done(); public native b3DynamicBvhBroadphase m_updates_done(int setter); // Number of updates done + public native @Cast("b3Scalar") float m_updates_ratio(); public native b3DynamicBvhBroadphase m_updates_ratio(float setter); // m_updates_done/m_updates_call + public native int m_pid(); public native b3DynamicBvhBroadphase m_pid(int setter); // Parse id + public native int m_cid(); public native b3DynamicBvhBroadphase m_cid(int setter); // Cleanup index + public native @Cast("bool") boolean m_releasepaircache(); public native b3DynamicBvhBroadphase m_releasepaircache(boolean setter); // Release pair cache on delete + public native @Cast("bool") boolean m_deferedcollide(); public native b3DynamicBvhBroadphase m_deferedcollide(boolean setter); // Defere dynamic/static collision to collide call + public native @Cast("bool") boolean m_needcleanup(); public native b3DynamicBvhBroadphase m_needcleanup(boolean setter); // Need to run cleanup? +// #if B3_DBVT_BP_PROFILE +// #endif + /* Methods */ + public b3DynamicBvhBroadphase(int proxyCapacity, b3OverlappingPairCache paircache/*=0*/) { super((Pointer)null); allocate(proxyCapacity, paircache); } + private native void allocate(int proxyCapacity, b3OverlappingPairCache paircache/*=0*/); + public b3DynamicBvhBroadphase(int proxyCapacity) { super((Pointer)null); allocate(proxyCapacity); } + private native void allocate(int proxyCapacity); + public native void collide(b3Dispatcher dispatcher); + public native void optimize(); + + /* b3BroadphaseInterface Implementation */ + public native b3BroadphaseProxy createProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int objectIndex, Pointer userPtr, int collisionFilterGroup, int collisionFilterMask); + public native void destroyProxy(b3BroadphaseProxy proxy, b3Dispatcher dispatcher); + public native void setAabb(int objectId, @Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, b3Dispatcher dispatcher); + public native void rayTest(@Const @ByRef b3Vector3 rayFrom, @Const @ByRef b3Vector3 rayTo, @ByRef b3BroadphaseRayCallback rayCallback, @Const @ByRef(nullValue = "b3Vector3(b3MakeVector3(0, 0, 0))") b3Vector3 aabbMin, @Const @ByRef(nullValue = "b3Vector3(b3MakeVector3(0, 0, 0))") b3Vector3 aabbMax); + public native void rayTest(@Const @ByRef b3Vector3 rayFrom, @Const @ByRef b3Vector3 rayTo, @ByRef b3BroadphaseRayCallback rayCallback); + public native void aabbTest(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, @ByRef b3BroadphaseAabbCallback callback); + + //virtual void getAabb(b3BroadphaseProxy* proxy,b3Vector3& aabbMin, b3Vector3& aabbMax ) const; + public native void getAabb(int objectId, @ByRef b3Vector3 aabbMin, @ByRef b3Vector3 aabbMax); + public native void calculateOverlappingPairs(b3Dispatcher dispatcher/*=0*/); + public native void calculateOverlappingPairs(); + public native b3OverlappingPairCache getOverlappingPairCache(); + public native void getBroadphaseAabb(@ByRef b3Vector3 aabbMin, @ByRef b3Vector3 aabbMax); + public native void printStats(); + + /**reset broadphase internal structures, to ensure determinism/reproducability */ + public native void resetPool(b3Dispatcher dispatcher); + + public native void performDeferredRemoval(b3Dispatcher dispatcher); + + public native void setVelocityPrediction(@Cast("b3Scalar") float prediction); + public native @Cast("b3Scalar") float getVelocityPrediction(); + + /**this setAabbForceUpdate is similar to setAabb but always forces the aabb update. + * it is not part of the b3BroadphaseInterface but specific to b3DynamicBvhBroadphase. + * it bypasses certain optimizations that prevent aabb updates (when the aabb shrinks), see + * http://code.google.com/p/bullet/issues/detail?id=223 */ + public native void setAabbForceUpdate(b3BroadphaseProxy absproxy, @Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, b3Dispatcher arg3); + + //static void benchmark(b3BroadphaseInterface*); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuChildShape.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuChildShape.java new file mode 100644 index 00000000000..832bb65924a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuChildShape.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3GpuChildShape extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuChildShape() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuChildShape(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuChildShape(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuChildShape position(long position) { + return (b3GpuChildShape)super.position(position); + } + @Override public b3GpuChildShape getPointer(long i) { + return new b3GpuChildShape((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_childPosition(); public native b3GpuChildShape m_childPosition(b3Vector3 setter); + public native @ByRef b3Quaternion m_childOrientation(); public native b3GpuChildShape m_childOrientation(b3Quaternion setter); + public native int m_shapeIndex(); public native b3GpuChildShape m_shapeIndex(int setter); //used for SHAPE_COMPOUND_OF_CONVEX_HULLS + public native int m_capsuleAxis(); public native b3GpuChildShape m_capsuleAxis(int setter); + public native float m_radius(); public native b3GpuChildShape m_radius(float setter); //used for childshape of SHAPE_COMPOUND_OF_SPHERES or SHAPE_COMPOUND_OF_CAPSULES + public native int m_numChildShapes(); public native b3GpuChildShape m_numChildShapes(int setter); //used for compound shape + public native float m_height(); public native b3GpuChildShape m_height(float setter); //used for childshape of SHAPE_COMPOUND_OF_CAPSULES + public native int m_collidableShapeIndex(); public native b3GpuChildShape m_collidableShapeIndex(int setter); + public native int m_shapeType(); public native b3GpuChildShape m_shapeType(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuChildShapeArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuChildShapeArray.java new file mode 100644 index 00000000000..6caf51eec4a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuChildShapeArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3GpuChildShapeArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuChildShapeArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuChildShapeArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3GpuChildShapeArray position(long position) { + return (b3GpuChildShapeArray)super.position(position); + } + @Override public b3GpuChildShapeArray getPointer(long i) { + return new b3GpuChildShapeArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3GpuChildShapeArray put(@Const @ByRef b3GpuChildShapeArray other); + public b3GpuChildShapeArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3GpuChildShapeArray(@Const @ByRef b3GpuChildShapeArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3GpuChildShapeArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3GpuChildShape at(int n); + + public native @ByRef @Name("operator []") b3GpuChildShape get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3GpuChildShape()") b3GpuChildShape fillData); + public native void resize(int newsize); + public native @ByRef b3GpuChildShape expandNonInitializing(); + + public native @ByRef b3GpuChildShape expand(@Const @ByRef(nullValue = "b3GpuChildShape()") b3GpuChildShape fillValue); + public native @ByRef b3GpuChildShape expand(); + + public native void push_back(@Const @ByRef b3GpuChildShape _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3GpuChildShapeArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuFace.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuFace.java new file mode 100644 index 00000000000..65faa99017c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuFace.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3GpuFace extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuFace() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuFace(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuFace(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuFace position(long position) { + return (b3GpuFace)super.position(position); + } + @Override public b3GpuFace getPointer(long i) { + return new b3GpuFace((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_plane(); public native b3GpuFace m_plane(b3Vector3 setter); + public native int m_indexOffset(); public native b3GpuFace m_indexOffset(int setter); + public native int m_numIndices(); public native b3GpuFace m_numIndices(int setter); + public native int m_unusedPadding1(); public native b3GpuFace m_unusedPadding1(int setter); + public native int m_unusedPadding2(); public native b3GpuFace m_unusedPadding2(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuFaceArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuFaceArray.java new file mode 100644 index 00000000000..e54ec3eb833 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3GpuFaceArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3GpuFaceArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuFaceArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuFaceArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3GpuFaceArray position(long position) { + return (b3GpuFaceArray)super.position(position); + } + @Override public b3GpuFaceArray getPointer(long i) { + return new b3GpuFaceArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3GpuFaceArray put(@Const @ByRef b3GpuFaceArray other); + public b3GpuFaceArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3GpuFaceArray(@Const @ByRef b3GpuFaceArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3GpuFaceArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3GpuFace at(int n); + + public native @ByRef @Name("operator []") b3GpuFace get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3GpuFace()") b3GpuFace fillData); + public native void resize(int newsize); + public native @ByRef b3GpuFace expandNonInitializing(); + + public native @ByRef b3GpuFace expand(@Const @ByRef(nullValue = "b3GpuFace()") b3GpuFace fillValue); + public native @ByRef b3GpuFace expand(); + + public native void push_back(@Const @ByRef b3GpuFace _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3GpuFaceArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3HashedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3HashedOverlappingPairCache.java new file mode 100644 index 00000000000..3f5135e73a4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3HashedOverlappingPairCache.java @@ -0,0 +1,65 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/** Hash-space based Pair Cache, thanks to Erin Catto, Box2D, http://www.box2d.org, and Pierre Terdiman, Codercorner, http://codercorner.com */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3HashedOverlappingPairCache extends b3OverlappingPairCache { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3HashedOverlappingPairCache(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3HashedOverlappingPairCache(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3HashedOverlappingPairCache position(long position) { + return (b3HashedOverlappingPairCache)super.position(position); + } + @Override public b3HashedOverlappingPairCache getPointer(long i) { + return new b3HashedOverlappingPairCache((Pointer)this).offsetAddress(i); + } + + public b3HashedOverlappingPairCache() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void removeOverlappingPairsContainingProxy(int proxy, b3Dispatcher dispatcher); + + public native Pointer removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher dispatcher); + + public native @Cast("bool") boolean needsBroadphaseCollision(int proxy0, int proxy1); + + // Add a pair and return the new pair. If the pair already exists, + // no new pair is created and the old one is returned. + public native @Cast("b3BroadphasePair*") b3Int4 addOverlappingPair(int proxy0, int proxy1); + + public native void cleanProxyFromPairs(int proxy, b3Dispatcher dispatcher); + + public native void processAllOverlappingPairs(b3OverlapCallback arg0, b3Dispatcher dispatcher); + + public native @Cast("b3BroadphasePair*") b3Int4 getOverlappingPairArrayPtr(); + + public native @Cast("b3BroadphasePairArray*") @ByRef b3AabbArray getOverlappingPairArray(); + + public native void cleanOverlappingPair(@Cast("b3BroadphasePair*") @ByRef b3Int4 pair, b3Dispatcher dispatcher); + + public native @Cast("b3BroadphasePair*") b3Int4 findPair(int proxy0, int proxy1); + + public native int GetCount(); + // b3BroadphasePair* GetPairs() { return m_pairs; } + + public native b3OverlapFilterCallback getOverlapFilterCallback(); + + public native void setOverlapFilterCallback(b3OverlapFilterCallback callback); + + public native int getNumOverlappingPairs(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3InertiaData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3InertiaData.java new file mode 100644 index 00000000000..d79c7a9a2f3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3InertiaData.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3InertiaData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3InertiaData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3InertiaData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3InertiaData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3InertiaData position(long position) { + return (b3InertiaData)super.position(position); + } + @Override public b3InertiaData getPointer(long i) { + return new b3InertiaData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Matrix3x3 m_invInertiaWorld(); public native b3InertiaData m_invInertiaWorld(b3Matrix3x3 setter); + public native @ByRef b3Matrix3x3 m_initInvInertia(); public native b3InertiaData m_initInvInertia(b3Matrix3x3 setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MprSimplex_t.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MprSimplex_t.java new file mode 100644 index 00000000000..5280b56c2f7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MprSimplex_t.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Name("_b3MprSimplex_t") @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3MprSimplex_t extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3MprSimplex_t() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3MprSimplex_t(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3MprSimplex_t(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3MprSimplex_t position(long position) { + return (b3MprSimplex_t)super.position(position); + } + @Override public b3MprSimplex_t getPointer(long i) { + return new b3MprSimplex_t((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3MprSupport_t ps(int i); public native b3MprSimplex_t ps(int i, b3MprSupport_t setter); + @MemberGetter public native b3MprSupport_t ps(); + /** index of last added point */ + public native int last(); public native b3MprSimplex_t last(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MprSupport_t.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MprSupport_t.java new file mode 100644 index 00000000000..d4dd6a551b3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MprSupport_t.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Name("_b3MprSupport_t") @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3MprSupport_t extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3MprSupport_t() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3MprSupport_t(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3MprSupport_t(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3MprSupport_t position(long position) { + return (b3MprSupport_t)super.position(position); + } + @Override public b3MprSupport_t getPointer(long i) { + return new b3MprSupport_t((Pointer)this).offsetAddress(i); + } + + /** Support point in minkowski sum */ + public native @ByRef b3Vector3 v(); public native b3MprSupport_t v(b3Vector3 setter); + /** Support point in obj1 */ + public native @ByRef b3Vector3 v1(); public native b3MprSupport_t v1(b3Vector3 setter); + /** Support point in obj2 */ + public native @ByRef b3Vector3 v2(); public native b3MprSupport_t v2(b3Vector3 setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MyFace.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MyFace.java new file mode 100644 index 00000000000..11f13f65e2a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MyFace.java @@ -0,0 +1,37 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3MyFace extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3MyFace() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3MyFace(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3MyFace(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3MyFace position(long position) { + return (b3MyFace)super.position(position); + } + @Override public b3MyFace getPointer(long i) { + return new b3MyFace((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3IntArray m_indices(); public native b3MyFace m_indices(b3IntArray setter); + public native @Cast("b3Scalar") float m_plane(int i); public native b3MyFace m_plane(int i, float setter); + @MemberGetter public native @Cast("b3Scalar*") FloatPointer m_plane(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MyFaceArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MyFaceArray.java new file mode 100644 index 00000000000..be733cf6c3f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3MyFaceArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3MyFaceArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3MyFaceArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3MyFaceArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3MyFaceArray position(long position) { + return (b3MyFaceArray)super.position(position); + } + @Override public b3MyFaceArray getPointer(long i) { + return new b3MyFaceArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3MyFaceArray put(@Const @ByRef b3MyFaceArray other); + public b3MyFaceArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3MyFaceArray(@Const @ByRef b3MyFaceArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3MyFaceArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3MyFace at(int n); + + public native @ByRef @Name("operator []") b3MyFace get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3MyFace()") b3MyFace fillData); + public native void resize(int newsize); + public native @ByRef b3MyFace expandNonInitializing(); + + public native @ByRef b3MyFace expand(@Const @ByRef(nullValue = "b3MyFace()") b3MyFace fillValue); + public native @ByRef b3MyFace expand(); + + public native void push_back(@Const @ByRef b3MyFace _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3MyFaceArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3NullPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3NullPairCache.java new file mode 100644 index 00000000000..3885c934f6c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3NullPairCache.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/**b3NullPairCache skips add/removal of overlapping pairs. Userful for benchmarking and unit testing. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3NullPairCache extends b3OverlappingPairCache { + static { Loader.load(); } + /** Default native constructor. */ + public b3NullPairCache() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3NullPairCache(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3NullPairCache(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3NullPairCache position(long position) { + return (b3NullPairCache)super.position(position); + } + @Override public b3NullPairCache getPointer(long i) { + return new b3NullPairCache((Pointer)this).offsetAddress(i); + } + + public native @Cast("b3BroadphasePair*") b3Int4 getOverlappingPairArrayPtr(); + public native @Cast("b3BroadphasePairArray*") @ByRef b3AabbArray getOverlappingPairArray(); + + public native void cleanOverlappingPair(@Cast("b3BroadphasePair*") @ByRef b3Int4 arg0, b3Dispatcher arg1); + + public native int getNumOverlappingPairs(); + + public native void cleanProxyFromPairs(int arg0, b3Dispatcher arg1); + + public native void setOverlapFilterCallback(b3OverlapFilterCallback arg0); + + public native void processAllOverlappingPairs(b3OverlapCallback arg0, b3Dispatcher arg1); + + public native @Cast("b3BroadphasePair*") b3Int4 findPair(int arg0, int arg1); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + // virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* /* ghostPairCallback */) + // { + // + // } + + public native @Cast("b3BroadphasePair*") b3Int4 addOverlappingPair(int arg0, int arg1); + + public native Pointer removeOverlappingPair(int arg0, int arg1, b3Dispatcher arg2); + + public native void removeOverlappingPairsContainingProxy(int arg0, b3Dispatcher arg1); + + public native void sortOverlappingPairs(b3Dispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapCallback.java new file mode 100644 index 00000000000..168e908c99f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3OverlapCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OverlapCallback(Pointer p) { super(p); } + + //return true for deletion of the pair + public native @Cast("bool") boolean processOverlap(@Cast("b3BroadphasePair*") @ByRef b3Int4 pair); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapFilterCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapFilterCallback.java new file mode 100644 index 00000000000..33f5cce7a49 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapFilterCallback.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3OverlapFilterCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OverlapFilterCallback(Pointer p) { super(p); } + + // return true when pairs need collision + public native @Cast("bool") boolean needBroadphaseCollision(int proxy0, int proxy1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlappingPairCache.java new file mode 100644 index 00000000000..6dfd35e7610 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlappingPairCache.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/**The b3OverlappingPairCache provides an interface for overlapping pair management (add, remove, storage), used by the b3BroadphaseInterface broadphases. + * The b3HashedOverlappingPairCache and b3SortedOverlappingPairCache classes are two implementations. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3OverlappingPairCache extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OverlappingPairCache(Pointer p) { super(p); } + // this is needed so we can get to the derived class destructor + + public native @Cast("b3BroadphasePair*") b3Int4 getOverlappingPairArrayPtr(); + + public native @Cast("b3BroadphasePairArray*") @ByRef b3AabbArray getOverlappingPairArray(); + + public native void cleanOverlappingPair(@Cast("b3BroadphasePair*") @ByRef b3Int4 pair, b3Dispatcher dispatcher); + + public native int getNumOverlappingPairs(); + + public native void cleanProxyFromPairs(int proxy, b3Dispatcher dispatcher); + + public native void setOverlapFilterCallback(b3OverlapFilterCallback callback); + + public native void processAllOverlappingPairs(b3OverlapCallback arg0, b3Dispatcher dispatcher); + + public native @Cast("b3BroadphasePair*") b3Int4 findPair(int proxy0, int proxy1); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + //virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback)=0; + + public native @Cast("b3BroadphasePair*") b3Int4 addOverlappingPair(int proxy0, int proxy1); + public native Pointer removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher dispatcher); + public native void removeOverlappingPairsContainingProxy(int arg0, b3Dispatcher arg1); + + public native void sortOverlappingPairs(b3Dispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3QuantizedBvhNodeData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3QuantizedBvhNodeData.java new file mode 100644 index 00000000000..659e092c25e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3QuantizedBvhNodeData.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/**b3QuantizedBvhNodeData is a compressed aabb node, 16 bytes. + * Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range). */ + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3QuantizedBvhNodeData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3QuantizedBvhNodeData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3QuantizedBvhNodeData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3QuantizedBvhNodeData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3QuantizedBvhNodeData position(long position) { + return (b3QuantizedBvhNodeData)super.position(position); + } + @Override public b3QuantizedBvhNodeData getPointer(long i) { + return new b3QuantizedBvhNodeData((Pointer)this).offsetAddress(i); + } + + //12 bytes + public native @Cast("unsigned short int") short m_quantizedAabbMin(int i); public native b3QuantizedBvhNodeData m_quantizedAabbMin(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMin(); + public native @Cast("unsigned short int") short m_quantizedAabbMax(int i); public native b3QuantizedBvhNodeData m_quantizedAabbMax(int i, short setter); + @MemberGetter public native @Cast("unsigned short int*") ShortPointer m_quantizedAabbMax(); + //4 bytes + public native int m_escapeIndexOrTriangleIndex(); public native b3QuantizedBvhNodeData m_escapeIndexOrTriangleIndex(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayHit.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayHit.java new file mode 100644 index 00000000000..ce869e8b97c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayHit.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3RayHit extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3RayHit() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3RayHit(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RayHit(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3RayHit position(long position) { + return (b3RayHit)super.position(position); + } + @Override public b3RayHit getPointer(long i) { + return new b3RayHit((Pointer)this).offsetAddress(i); + } + + public native @Cast("b3Scalar") float m_hitFraction(); public native b3RayHit m_hitFraction(float setter); + public native int m_hitBody(); public native b3RayHit m_hitBody(int setter); + public native int m_hitResult1(); public native b3RayHit m_hitResult1(int setter); + public native int m_hitResult2(); public native b3RayHit m_hitResult2(int setter); + public native @ByRef b3Vector3 m_hitPoint(); public native b3RayHit m_hitPoint(b3Vector3 setter); + public native @ByRef b3Vector3 m_hitNormal(); public native b3RayHit m_hitNormal(b3Vector3 setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayInfo.java new file mode 100644 index 00000000000..852564cda03 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayInfo.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3RayInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3RayInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3RayInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RayInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3RayInfo position(long position) { + return (b3RayInfo)super.position(position); + } + @Override public b3RayInfo getPointer(long i) { + return new b3RayInfo((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_from(); public native b3RayInfo m_from(b3Vector3 setter); + public native @ByRef b3Vector3 m_to(); public native b3RayInfo m_to(b3Vector3 setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RigidBodyData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RigidBodyData.java new file mode 100644 index 00000000000..8c2acdda84f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RigidBodyData.java @@ -0,0 +1,43 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3RigidBodyData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3RigidBodyData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3RigidBodyData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RigidBodyData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3RigidBodyData position(long position) { + return (b3RigidBodyData)super.position(position); + } + @Override public b3RigidBodyData getPointer(long i) { + return new b3RigidBodyData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_pos(); public native b3RigidBodyData m_pos(b3Vector3 setter); + public native @ByRef b3Quaternion m_quat(); public native b3RigidBodyData m_quat(b3Quaternion setter); + public native @ByRef b3Vector3 m_linVel(); public native b3RigidBodyData m_linVel(b3Vector3 setter); + public native @ByRef b3Vector3 m_angVel(); public native b3RigidBodyData m_angVel(b3Vector3 setter); + + public native int m_collidableIdx(); public native b3RigidBodyData m_collidableIdx(int setter); + public native float m_invMass(); public native b3RigidBodyData m_invMass(float setter); + public native float m_restituitionCoeff(); public native b3RigidBodyData m_restituitionCoeff(float setter); + public native float m_frictionCoeff(); public native b3RigidBodyData m_frictionCoeff(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RigidBodyDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RigidBodyDataArray.java new file mode 100644 index 00000000000..78088410223 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RigidBodyDataArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3RigidBodyDataArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RigidBodyDataArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3RigidBodyDataArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3RigidBodyDataArray position(long position) { + return (b3RigidBodyDataArray)super.position(position); + } + @Override public b3RigidBodyDataArray getPointer(long i) { + return new b3RigidBodyDataArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3RigidBodyDataArray put(@Const @ByRef b3RigidBodyDataArray other); + public b3RigidBodyDataArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3RigidBodyDataArray(@Const @ByRef b3RigidBodyDataArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3RigidBodyDataArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3RigidBodyData at(int n); + + public native @ByRef @Name("operator []") b3RigidBodyData get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3RigidBodyData()") b3RigidBodyData fillData); + public native void resize(int newsize); + public native @ByRef b3RigidBodyData expandNonInitializing(); + + public native @ByRef b3RigidBodyData expand(@Const @ByRef(nullValue = "b3RigidBodyData()") b3RigidBodyData fillValue); + public native @ByRef b3RigidBodyData expand(); + + public native void push_back(@Const @ByRef b3RigidBodyData _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3RigidBodyDataArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3SortedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3SortedOverlappingPairCache.java new file mode 100644 index 00000000000..43da0f7a452 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3SortedOverlappingPairCache.java @@ -0,0 +1,70 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + + +/**b3SortedOverlappingPairCache maintains the objects with overlapping AABB + * Typically managed by the Broadphase, Axis3Sweep or b3SimpleBroadphase */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3SortedOverlappingPairCache extends b3OverlappingPairCache { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SortedOverlappingPairCache(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3SortedOverlappingPairCache(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3SortedOverlappingPairCache position(long position) { + return (b3SortedOverlappingPairCache)super.position(position); + } + @Override public b3SortedOverlappingPairCache getPointer(long i) { + return new b3SortedOverlappingPairCache((Pointer)this).offsetAddress(i); + } + + public b3SortedOverlappingPairCache() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void processAllOverlappingPairs(b3OverlapCallback arg0, b3Dispatcher dispatcher); + + public native Pointer removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher dispatcher); + + public native void cleanOverlappingPair(@Cast("b3BroadphasePair*") @ByRef b3Int4 pair, b3Dispatcher dispatcher); + + public native @Cast("b3BroadphasePair*") b3Int4 addOverlappingPair(int proxy0, int proxy1); + + public native @Cast("b3BroadphasePair*") b3Int4 findPair(int proxy0, int proxy1); + + public native void cleanProxyFromPairs(int proxy, b3Dispatcher dispatcher); + + public native void removeOverlappingPairsContainingProxy(int proxy, b3Dispatcher dispatcher); + + public native @Cast("bool") boolean needsBroadphaseCollision(int proxy0, int proxy1); + + public native @Cast("b3BroadphasePairArray*") @ByRef b3AabbArray getOverlappingPairArray(); + + public native @Cast("b3BroadphasePair*") b3Int4 getOverlappingPairArrayPtr(); + + public native int getNumOverlappingPairs(); + + public native b3OverlapFilterCallback getOverlapFilterCallback(); + + public native void setOverlapFilterCallback(b3OverlapFilterCallback callback); + + public native @Cast("bool") boolean hasDeferredRemoval(); + + /* virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback) + { + m_ghostPairCallback = ghostPairCallback; + } + */ + public native void sortOverlappingPairs(b3Dispatcher dispatcher); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNNArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNNArray.java new file mode 100644 index 00000000000..3b085f696d6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNNArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class sStkNNArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkNNArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sStkNNArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public sStkNNArray position(long position) { + return (sStkNNArray)super.position(position); + } + @Override public sStkNNArray getPointer(long i) { + return new sStkNNArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") sStkNNArray put(@Const @ByRef sStkNNArray other); + public sStkNNArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public sStkNNArray(@Const @ByRef sStkNNArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef sStkNNArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3DynamicBvh.sStkNN at(int n); + + public native @ByRef @Name("operator []") b3DynamicBvh.sStkNN get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3DynamicBvh::sStkNN()") b3DynamicBvh.sStkNN fillData); + public native void resize(int newsize); + public native @ByRef b3DynamicBvh.sStkNN expandNonInitializing(); + + public native @ByRef b3DynamicBvh.sStkNN expand(@Const @ByRef(nullValue = "b3DynamicBvh::sStkNN()") b3DynamicBvh.sStkNN fillValue); + public native @ByRef b3DynamicBvh.sStkNN expand(); + + public native void push_back(@Const @ByRef b3DynamicBvh.sStkNN _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef sStkNNArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNPSArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNPSArray.java new file mode 100644 index 00000000000..a7db4a1624f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNPSArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class sStkNPSArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sStkNPSArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sStkNPSArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public sStkNPSArray position(long position) { + return (sStkNPSArray)super.position(position); + } + @Override public sStkNPSArray getPointer(long i) { + return new sStkNPSArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") sStkNPSArray put(@Const @ByRef sStkNPSArray other); + public sStkNPSArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public sStkNPSArray(@Const @ByRef sStkNPSArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef sStkNPSArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3DynamicBvh.sStkNPS at(int n); + + public native @ByRef @Name("operator []") b3DynamicBvh.sStkNPS get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3DynamicBvh::sStkNPS()") b3DynamicBvh.sStkNPS fillData); + public native void resize(int newsize); + public native @ByRef b3DynamicBvh.sStkNPS expandNonInitializing(); + + public native @ByRef b3DynamicBvh.sStkNPS expand(@Const @ByRef(nullValue = "b3DynamicBvh::sStkNPS()") b3DynamicBvh.sStkNPS fillValue); + public native @ByRef b3DynamicBvh.sStkNPS expand(); + + public native void push_back(@Const @ByRef b3DynamicBvh.sStkNPS _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef sStkNPSArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/MyTest.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/MyTest.java new file mode 100644 index 00000000000..fb0a36ccd9c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/MyTest.java @@ -0,0 +1,33 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class MyTest extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public MyTest() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public MyTest(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public MyTest(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public MyTest position(long position) { + return (MyTest)super.position(position); + } + @Override public MyTest getPointer(long i) { + return new MyTest((Pointer)this).offsetAddress(i); + } + + public native int bla(); public native MyTest bla(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int4Array.java new file mode 100644 index 00000000000..b5d5c272c23 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int4Array.java @@ -0,0 +1,85 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Int4Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Int4Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Int4Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Int4Array position(long position) { + return (b3Int4Array)super.position(position); + } + @Override public b3Int4Array getPointer(long i) { + return new b3Int4Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3Int4Array put(@Const @ByRef b3Int4Array other); + public b3Int4Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3Int4Array(@Const @ByRef b3Int4Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3Int4Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3Int4 at(int n); + + public native @ByRef @Name("operator []") b3Int4 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3Int4()") b3Int4 fillData); + public native void resize(int newsize); + public native @ByRef b3Int4 expandNonInitializing(); + + public native @ByRef b3Int4 expand(@Const @ByRef(nullValue = "b3Int4()") b3Int4 fillValue); + public native @ByRef b3Int4 expand(); + + public native void push_back(@Const @ByRef b3Int4 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3Int4Array otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3IntArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3IntArray.java new file mode 100644 index 00000000000..6703b7f9ff8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3IntArray.java @@ -0,0 +1,89 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + //for placement new +// #endif //B3_USE_PLACEMENT_NEW + +/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3IntArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3IntArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3IntArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3IntArray position(long position) { + return (b3IntArray)super.position(position); + } + @Override public b3IntArray getPointer(long i) { + return new b3IntArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3IntArray put(@Const @ByRef b3IntArray other); + public b3IntArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3IntArray(@Const @ByRef b3IntArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3IntArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef IntPointer at(int n); + + public native @ByRef @Name("operator []") IntPointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, int fillData/*=int()*/); + public native void resize(int newsize); + public native @ByRef IntPointer expandNonInitializing(); + + public native @ByRef IntPointer expand(int fillValue/*=int()*/); + public native @ByRef IntPointer expand(); + + public native void push_back(int _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(int key); + + public native int findLinearSearch(int key); + + public native int findLinearSearch2(int key); + + public native void remove(int key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3IntArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3Array.java new file mode 100644 index 00000000000..c2072a7d93a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Vector3Array.java @@ -0,0 +1,85 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Vector3Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Vector3Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Vector3Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Vector3Array position(long position) { + return (b3Vector3Array)super.position(position); + } + @Override public b3Vector3Array getPointer(long i) { + return new b3Vector3Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3Vector3Array put(@Const @ByRef b3Vector3Array other); + public b3Vector3Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3Vector3Array(@Const @ByRef b3Vector3Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3Vector3Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3Vector3 at(int n); + + public native @ByRef @Name("operator []") b3Vector3 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3Vector3()") b3Vector3 fillData); + public native void resize(int newsize); + public native @ByRef b3Vector3 expandNonInitializing(); + + public native @ByRef b3Vector3 expand(@Const @ByRef(nullValue = "b3Vector3()") b3Vector3 fillValue); + public native @ByRef b3Vector3 expand(); + + public native void push_back(@Const @ByRef b3Vector3 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Const @ByRef b3Vector3 key); + + public native int findLinearSearch(@Const @ByRef b3Vector3 key); + + public native int findLinearSearch2(@Const @ByRef b3Vector3 key); + + public native void remove(@Const @ByRef b3Vector3 key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3Vector3Array otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java new file mode 100644 index 00000000000..e2246476db2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java @@ -0,0 +1,1247 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.global; + +import org.bytedeco.bullet.Bullet3Collision.*; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +public class Bullet3Collision extends org.bytedeco.bullet.presets.Bullet3Collision { + static { Loader.load(); } + +// Parsed from Bullet3Common/b3AlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_OBJECT_ARRAY__ +// #define B3_OBJECT_ARRAY__ + +// #include "b3Scalar.h" // has definitions like B3_FORCE_INLINE +// #include "b3AlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable B3_USE_PLACEMENT_NEW + * then the b3AlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable B3_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int B3_USE_PLACEMENT_NEW = 1; +//#define B3_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define B3_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef B3_USE_MEMCPY +// #include +// #include +// #endif //B3_USE_MEMCPY + +// #ifdef B3_USE_PLACEMENT_NEW +// #include +// Targeting ../Bullet3Collision/b3AabbArray.java + + +// Targeting ../Bullet3Collision/b3CollidableArray.java + + +// Targeting ../Bullet3Collision/b3Contact4DataArray.java + + +// Targeting ../Bullet3Collision/b3ConvexPolyhedronDataArray.java + + +// Targeting ../Bullet3Collision/b3DbvtProxyArray.java + + +// Targeting ../Bullet3Collision/sStkNNArray.java + + +// Targeting ../Bullet3Collision/sStkNPSArray.java + + +// Targeting ../Bullet3Collision/b3GpuChildShapeArray.java + + +// Targeting ../Bullet3Collision/b3GpuFaceArray.java + + +// Targeting ../Bullet3Collision/b3MyFaceArray.java + + +// Targeting ../Bullet3Collision/b3RigidBodyDataArray.java + + + +// #endif //B3_OBJECT_ARRAY__ + + +// Parsed from Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +/**b3DynamicBvh implementation by Nathanael Presson */ + +// #ifndef B3_DYNAMIC_BOUNDING_VOLUME_TREE_H +// #define B3_DYNAMIC_BOUNDING_VOLUME_TREE_H + +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Common/b3Transform.h" +// #include "Bullet3Geometry/b3AabbUtil.h" + +// +// Compile time configuration +// + +// Implementation profiles +public static final int B3_DBVT_IMPL_GENERIC = 0; // Generic implementation +public static final int B3_DBVT_IMPL_SSE = 1; // SSE + +// Template implementation of ICollide +// #ifdef _WIN32 +// #else +// #define B3_DBVT_USE_TEMPLATE 0 +// #endif + +// Use only intrinsics instead of inline asm +public static final int B3_DBVT_USE_INTRINSIC_SSE = 1; + +// Using memmov for collideOCL +public static final int B3_DBVT_USE_MEMMOVE = 1; + +// Enable benchmarking code +public static final int B3_DBVT_ENABLE_BENCHMARK = 0; + +// Inlining +// #define B3_DBVT_INLINE B3_FORCE_INLINE + +// Specific methods implementation + +//SSE gives errors on a MSVC 7.1 +// #if defined(B3_USE_SSE) //&& defined (_WIN32) +// #else +public static final int B3_DBVT_SELECT_IMPL = B3_DBVT_IMPL_GENERIC; +public static final int B3_DBVT_MERGE_IMPL = B3_DBVT_IMPL_GENERIC; +public static final int B3_DBVT_INT0_IMPL = B3_DBVT_IMPL_GENERIC; +// #endif + +// #if (B3_DBVT_SELECT_IMPL == B3_DBVT_IMPL_SSE) || +// (B3_DBVT_MERGE_IMPL == B3_DBVT_IMPL_SSE) || +// (B3_DBVT_INT0_IMPL == B3_DBVT_IMPL_SSE) +// #include +// #endif + +// +// Auto config and checks +// + +// #if B3_DBVT_USE_TEMPLATE +// #else +// #define B3_DBVT_VIRTUAL_DTOR(a) +// virtual ~a() {} +// #define B3_DBVT_VIRTUAL virtual +// #define B3_DBVT_PREFIX +// #define B3_DBVT_IPOLICY ICollide& policy +// #define B3_DBVT_CHECKTYPE +// #endif + +// #if B3_DBVT_USE_MEMMOVE +// #if !defined(__CELLOS_LV2__) && !defined(__MWERKS__) +// #include +// #endif +// #include +// #endif + +// #ifndef B3_DBVT_USE_TEMPLATE +// #error "B3_DBVT_USE_TEMPLATE undefined" +// Targeting ../Bullet3Collision/b3DbvtAabbMm.java + + + +// Types +// Targeting ../Bullet3Collision/b3DbvtNode.java + + +// Targeting ../Bullet3Collision/b3DynamicBvh.java + + + +// +// Inline's +// + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// + + +// +public static native @Cast("bool") boolean b3Intersect(@Const @ByRef b3DbvtAabbMm a, + @Const @ByRef b3DbvtAabbMm b); + +// +public static native @Cast("bool") boolean b3Intersect(@Const @ByRef b3DbvtAabbMm a, + @Const @ByRef b3Vector3 b); + +////////////////////////////////////// + +// +public static native @Cast("b3Scalar") float b3Proximity(@Const @ByRef b3DbvtAabbMm a, + @Const @ByRef b3DbvtAabbMm b); + +// +public static native int b3Select(@Const @ByRef b3DbvtAabbMm o, + @Const @ByRef b3DbvtAabbMm a, + @Const @ByRef b3DbvtAabbMm b); + +// +public static native void b3Merge(@Const @ByRef b3DbvtAabbMm a, + @Const @ByRef b3DbvtAabbMm b, + @ByRef b3DbvtAabbMm r); + +// +public static native @Cast("bool") boolean b3NotEqual(@Const @ByRef b3DbvtAabbMm a, + @Const @ByRef b3DbvtAabbMm b); + +// +// Inline's +// + +// + + +// + + +// + + + + +// #if 0 +// #endif + +// + + + + +// + + +// + + +// + + +// + + +// +// PP Cleanup +// + +// #undef B3_DBVT_USE_MEMMOVE +// #undef B3_DBVT_USE_TEMPLATE +// #undef B3_DBVT_VIRTUAL_DTOR +// #undef B3_DBVT_VIRTUAL +// #undef B3_DBVT_PREFIX +// #undef B3_DBVT_IPOLICY +// #undef B3_DBVT_CHECKTYPE +// #undef B3_DBVT_IMPL_GENERIC +// #undef B3_DBVT_IMPL_SSE +// #undef B3_DBVT_USE_INTRINSIC_SSE +// #undef B3_DBVT_SELECT_IMPL +// #undef B3_DBVT_MERGE_IMPL +// #undef B3_DBVT_INT0_IMPL + +// #endif + + +// Parsed from Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_OVERLAPPING_PAIR_H +// #define B3_OVERLAPPING_PAIR_H + +// #include "Bullet3Common/shared/b3Int4.h" + +public static final int B3_NEW_PAIR_MARKER = -1; +public static final int B3_REMOVED_PAIR_MARKER = -2; + +public static native @ByVal b3Int4 b3MakeBroadphasePair(int xx, int yy); +// Targeting ../Bullet3Collision/b3BroadphasePairSortPredicate.java + + + +public static native @Cast("bool") @Name("operator ==") boolean equals(@Cast("const b3BroadphasePair*") @ByRef b3Int4 a, @Cast("const b3BroadphasePair*") @ByRef b3Int4 b); + +// #endif //B3_OVERLAPPING_PAIR_H + + +// Parsed from Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_OVERLAPPING_PAIR_CACHE_H +// #define B3_OVERLAPPING_PAIR_CACHE_H + +// #include "Bullet3Common/shared/b3Int2.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" +// Targeting ../Bullet3Collision/b3Dispatcher.java + + +// #include "b3OverlappingPair.h" +// Targeting ../Bullet3Collision/b3OverlapCallback.java + + +// Targeting ../Bullet3Collision/b3OverlapFilterCallback.java + + + +public static native int b3g_removePairs(); public static native void b3g_removePairs(int setter); +public static native int b3g_addedPairs(); public static native void b3g_addedPairs(int setter); +public static native int b3g_findPairs(); public static native void b3g_findPairs(int setter); + +@MemberGetter public static native int B3_NULL_PAIR(); +// Targeting ../Bullet3Collision/b3OverlappingPairCache.java + + +// Targeting ../Bullet3Collision/b3HashedOverlappingPairCache.java + + +// Targeting ../Bullet3Collision/b3SortedOverlappingPairCache.java + + +// Targeting ../Bullet3Collision/b3NullPairCache.java + + + +// #endif //B3_OVERLAPPING_PAIR_CACHE_H + + +// Parsed from Bullet3Collision/BroadPhaseCollision/b3BroadphaseCallback.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_BROADPHASE_CALLBACK_H +// #define B3_BROADPHASE_CALLBACK_H + +// #include "Bullet3Common/b3Vector3.h" +// Targeting ../Bullet3Collision/b3BroadphaseAabbCallback.java + + +// Targeting ../Bullet3Collision/b3BroadphaseRayCallback.java + + + +// #endif //B3_BROADPHASE_CALLBACK_H + + +// Parsed from Bullet3Collision/BroadPhaseCollision/b3DynamicBvhBroadphase.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**b3DynamicBvhBroadphase implementation by Nathanael Presson */ +// #ifndef B3_DBVT_BROADPHASE_H +// #define B3_DBVT_BROADPHASE_H + +// #include "Bullet3Collision/BroadPhaseCollision/b3DynamicBvh.h" +// #include "Bullet3Collision/BroadPhaseCollision/b3OverlappingPairCache.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" + +// #include "b3BroadphaseCallback.h" + +// +// Compile time config +// + +// #define B3_DBVT_BP_PROFILE 0 +//#define B3_DBVT_BP_SORTPAIRS 1 +public static final int B3_DBVT_BP_PREVENTFALSEUPDATE = 0; +public static final int B3_DBVT_BP_ACCURATESLEEPING = 0; +public static final int B3_DBVT_BP_ENABLE_BENCHMARK = 0; +public static final double B3_DBVT_BP_MARGIN = (float)0.05; +// Targeting ../Bullet3Collision/b3BroadphaseProxy.java + + +// Targeting ../Bullet3Collision/b3DbvtProxy.java + + +// Targeting ../Bullet3Collision/b3DynamicBvhBroadphase.java + + + +// #endif + + +// Parsed from Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h + + +// #ifndef B3_AABB_H +// #define B3_AABB_H + +// #include "Bullet3Common/shared/b3Float4.h" +// #include "Bullet3Common/shared/b3Mat3x3.h" +// Targeting ../Bullet3Collision/b3Aabb.java + + + +public static native void b3TransformAabb2(@Const @ByRef b3Vector3 localAabbMin, @Const @ByRef b3Vector3 localAabbMax, float margin, + @Const @ByRef b3Vector3 pos, + @Const @ByRef b3Quaternion orn, + b3Vector3 aabbMinOut, b3Vector3 aabbMaxOut); + +/** conservative test for overlap between two aabbs */ +public static native @Cast("bool") boolean b3TestAabbAgainstAabb(@Const @ByRef b3Vector3 aabbMin1, @Const @ByRef b3Vector3 aabbMax1, + @Const @ByRef b3Vector3 aabbMin2, @Const @ByRef b3Vector3 aabbMax2); + +// #endif //B3_AABB_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/b3Config.h + +// #ifndef B3_CONFIG_H +// #define B3_CONFIG_H +// Targeting ../Bullet3Collision/b3Config.java + + + +// #endif //B3_CONFIG_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/b3Contact4.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_CONTACT4_H +// #define B3_CONTACT4_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h" +// Targeting ../Bullet3Collision/b3Contact4.java + + + +// #endif //B3_CONTACT4_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/b3ConvexUtility.h + + +/* +Copyright (c) 2012 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Erwin Coumans + +// #ifndef _BT_CONVEX_UTILITY_H +// #define _BT_CONVEX_UTILITY_H + +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Common/b3Transform.h" +// Targeting ../Bullet3Collision/b3MyFace.java + + +// Targeting ../Bullet3Collision/b3ConvexUtility.java + + +// #endif + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/b3CpuNarrowPhase.h + +// #ifndef B3_CPU_NARROWPHASE_H +// #define B3_CPU_NARROWPHASE_H + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h" +// #include "Bullet3Common/shared/b3Int4.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h" +// Targeting ../Bullet3Collision/b3CpuNarrowPhase.java + + + +// #endif //B3_CPU_NARROWPHASE_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h + + +// #ifndef B3_RAYCAST_INFO_H +// #define B3_RAYCAST_INFO_H + +// #include "Bullet3Common/b3Vector3.h" +// Targeting ../Bullet3Collision/b3RayInfo.java + + +// Targeting ../Bullet3Collision/b3RayHit.java + + + +// #endif //B3_RAYCAST_INFO_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/b3RigidBodyCL.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_RIGID_BODY_CL +// #define B3_RIGID_BODY_CL + +// #include "Bullet3Common/b3Scalar.h" +// #include "Bullet3Common/b3Matrix3x3.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" + +public static native float b3GetInvMass(@Const @ByRef b3RigidBodyData body); + +// #endif //B3_RIGID_BODY_CL + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h + + +// #ifndef B3_COLLIDABLE_H +// #define B3_COLLIDABLE_H + +// #include "Bullet3Common/shared/b3Float4.h" +// #include "Bullet3Common/shared/b3Quat.h" + +/** enum b3ShapeTypes */ +public static final int + SHAPE_HEIGHT_FIELD = 1, + + SHAPE_CONVEX_HULL = 3, + SHAPE_PLANE = 4, + SHAPE_CONCAVE_TRIMESH = 5, + SHAPE_COMPOUND_OF_CONVEX_HULLS = 6, + SHAPE_SPHERE = 7, + MAX_NUM_SHAPE_TYPES = 8; +// Targeting ../Bullet3Collision/b3Collidable.java + + +// Targeting ../Bullet3Collision/b3GpuChildShape.java + + +// Targeting ../Bullet3Collision/b3CompoundOverlappingPair.java + + + +// #endif //B3_COLLIDABLE_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h + + +// #ifndef B3_CONVEX_POLYHEDRON_DATA_H +// #define B3_CONVEX_POLYHEDRON_DATA_H + +// #include "Bullet3Common/shared/b3Float4.h" +// #include "Bullet3Common/shared/b3Quat.h" +// Targeting ../Bullet3Collision/b3GpuFace.java + + +// Targeting ../Bullet3Collision/b3ConvexPolyhedronData.java + + + +// #endif //B3_CONVEX_POLYHEDRON_DATA_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h + +// #ifndef B3_RIGIDBODY_DATA_H +// #define B3_RIGIDBODY_DATA_H + +// #include "Bullet3Common/shared/b3Float4.h" +// #include "Bullet3Common/shared/b3Quat.h" +// #include "Bullet3Common/shared/b3Mat3x3.h" +// Targeting ../Bullet3Collision/b3RigidBodyData.java + + +// Targeting ../Bullet3Collision/b3InertiaData.java + + + +// #endif //B3_RIGIDBODY_DATA_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h + + +// #ifndef B3_BVH_SUBTREE_INFO_DATA_H +// #define B3_BVH_SUBTREE_INFO_DATA_H +// Targeting ../Bullet3Collision/b3BvhSubtreeInfoData.java + + + +// #endif //B3_BVH_SUBTREE_INFO_DATA_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h + +// #ifndef B3_CONTACT4DATA_H +// #define B3_CONTACT4DATA_H + +// #include "Bullet3Common/shared/b3Float4.h" +// Targeting ../Bullet3Collision/b3Contact4Data.java + + + +public static native int b3Contact4Data_getNumPoints(@Const b3Contact4Data contact); + +public static native void b3Contact4Data_setNumPoints(b3Contact4Data contact, int numPoints); + +// #endif //B3_CONTACT4DATA_H + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3ContactConvexConvexSAT.h + + +// #ifndef B3_CONTACT_CONVEX_CONVEX_SAT_H +// #define B3_CONTACT_CONVEX_CONVEX_SAT_H + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3FindSeparatingAxis.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h" + +public static final int B3_MAX_VERTS = 1024; + +public static native @ByVal b3Vector3 b3Lerp3(@Const @ByRef b3Vector3 a, @Const @ByRef b3Vector3 b, float t); + +// Clips a face to the back of a plane, return the number of vertices out, stored in ppVtxOut +public static native int b3ClipFace(@Const b3Vector3 pVtxIn, int numVertsIn, @ByRef b3Vector3 planeNormalWS, float planeEqWS, b3Vector3 ppVtxOut); + +public static native int b3ClipFaceAgainstHull(@Const @ByRef b3Vector3 separatingNormal, @Const b3ConvexPolyhedronData hullA, + @Const @ByRef b3Vector3 posA, @Const @ByRef b3Quaternion ornA, b3Vector3 worldVertsB1, int numWorldVertsB1, + b3Vector3 worldVertsB2, int capacityWorldVertsB2, + float minDist, float maxDist, + @Const @ByRef b3Vector3Array verticesA, @Const @ByRef b3GpuFaceArray facesA, @Const @ByRef b3IntArray indicesA, + b3Vector3 contactsOut, + int contactCapacity); + +public static native int b3ClipHullAgainstHull(@Const @ByRef b3Vector3 separatingNormal, + @Const @ByRef b3ConvexPolyhedronData hullA, @Const @ByRef b3ConvexPolyhedronData hullB, + @Const @ByRef b3Vector3 posA, @Const @ByRef b3Quaternion ornA, @Const @ByRef b3Vector3 posB, @Const @ByRef b3Quaternion ornB, + b3Vector3 worldVertsB1, b3Vector3 worldVertsB2, int capacityWorldVerts, + float minDist, float maxDist, + @Const @ByRef b3Vector3Array verticesA, @Const @ByRef b3GpuFaceArray facesA, @Const @ByRef b3IntArray indicesA, + @Const @ByRef b3Vector3Array verticesB, @Const @ByRef b3GpuFaceArray facesB, @Const @ByRef b3IntArray indicesB, + + b3Vector3 contactsOut, + int contactCapacity); + +public static native int b3ClipHullHullSingle( + int bodyIndexA, int bodyIndexB, + @Const @ByRef b3Vector3 posA, + @Const @ByRef b3Quaternion ornA, + @Const @ByRef b3Vector3 posB, + @Const @ByRef b3Quaternion ornB, + + int collidableIndexA, int collidableIndexB, + + @Const b3RigidBodyDataArray bodyBuf, + b3Contact4DataArray globalContactOut, + @ByRef IntPointer nContacts, + + @Const @ByRef b3ConvexPolyhedronDataArray hostConvexDataA, + @Const @ByRef b3ConvexPolyhedronDataArray hostConvexDataB, + + @Const @ByRef b3Vector3Array verticesA, + @Const @ByRef b3Vector3Array uniqueEdgesA, + @Const @ByRef b3GpuFaceArray facesA, + @Const @ByRef b3IntArray indicesA, + + @Const @ByRef b3Vector3Array verticesB, + @Const @ByRef b3Vector3Array uniqueEdgesB, + @Const @ByRef b3GpuFaceArray facesB, + @Const @ByRef b3IntArray indicesB, + + @Const @ByRef b3CollidableArray hostCollidablesA, + @Const @ByRef b3CollidableArray hostCollidablesB, + @Const @ByRef b3Vector3 sepNormalWorldSpace, + int maxContactCapacity); +public static native int b3ClipHullHullSingle( + int bodyIndexA, int bodyIndexB, + @Const @ByRef b3Vector3 posA, + @Const @ByRef b3Quaternion ornA, + @Const @ByRef b3Vector3 posB, + @Const @ByRef b3Quaternion ornB, + + int collidableIndexA, int collidableIndexB, + + @Const b3RigidBodyDataArray bodyBuf, + b3Contact4DataArray globalContactOut, + @ByRef IntBuffer nContacts, + + @Const @ByRef b3ConvexPolyhedronDataArray hostConvexDataA, + @Const @ByRef b3ConvexPolyhedronDataArray hostConvexDataB, + + @Const @ByRef b3Vector3Array verticesA, + @Const @ByRef b3Vector3Array uniqueEdgesA, + @Const @ByRef b3GpuFaceArray facesA, + @Const @ByRef b3IntArray indicesA, + + @Const @ByRef b3Vector3Array verticesB, + @Const @ByRef b3Vector3Array uniqueEdgesB, + @Const @ByRef b3GpuFaceArray facesB, + @Const @ByRef b3IntArray indicesB, + + @Const @ByRef b3CollidableArray hostCollidablesA, + @Const @ByRef b3CollidableArray hostCollidablesB, + @Const @ByRef b3Vector3 sepNormalWorldSpace, + int maxContactCapacity); +public static native int b3ClipHullHullSingle( + int bodyIndexA, int bodyIndexB, + @Const @ByRef b3Vector3 posA, + @Const @ByRef b3Quaternion ornA, + @Const @ByRef b3Vector3 posB, + @Const @ByRef b3Quaternion ornB, + + int collidableIndexA, int collidableIndexB, + + @Const b3RigidBodyDataArray bodyBuf, + b3Contact4DataArray globalContactOut, + @ByRef int[] nContacts, + + @Const @ByRef b3ConvexPolyhedronDataArray hostConvexDataA, + @Const @ByRef b3ConvexPolyhedronDataArray hostConvexDataB, + + @Const @ByRef b3Vector3Array verticesA, + @Const @ByRef b3Vector3Array uniqueEdgesA, + @Const @ByRef b3GpuFaceArray facesA, + @Const @ByRef b3IntArray indicesA, + + @Const @ByRef b3Vector3Array verticesB, + @Const @ByRef b3Vector3Array uniqueEdgesB, + @Const @ByRef b3GpuFaceArray facesB, + @Const @ByRef b3IntArray indicesB, + + @Const @ByRef b3CollidableArray hostCollidablesA, + @Const @ByRef b3CollidableArray hostCollidablesB, + @Const @ByRef b3Vector3 sepNormalWorldSpace, + int maxContactCapacity); + +public static native int b3ContactConvexConvexSAT( + int pairIndex, + int bodyIndexA, int bodyIndexB, + int collidableIndexA, int collidableIndexB, + @Const @ByRef b3RigidBodyDataArray rigidBodies, + @Const @ByRef b3CollidableArray collidables, + @Const @ByRef b3ConvexPolyhedronDataArray convexShapes, + @Const @ByRef b3Vector3Array convexVertices, + @Const @ByRef b3Vector3Array uniqueEdges, + @Const @ByRef b3IntArray convexIndices, + @Const @ByRef b3GpuFaceArray faces, + @ByRef b3Contact4DataArray globalContactsOut, + @ByRef IntPointer nGlobalContactsOut, + int maxContactCapacity); +public static native int b3ContactConvexConvexSAT( + int pairIndex, + int bodyIndexA, int bodyIndexB, + int collidableIndexA, int collidableIndexB, + @Const @ByRef b3RigidBodyDataArray rigidBodies, + @Const @ByRef b3CollidableArray collidables, + @Const @ByRef b3ConvexPolyhedronDataArray convexShapes, + @Const @ByRef b3Vector3Array convexVertices, + @Const @ByRef b3Vector3Array uniqueEdges, + @Const @ByRef b3IntArray convexIndices, + @Const @ByRef b3GpuFaceArray faces, + @ByRef b3Contact4DataArray globalContactsOut, + @ByRef IntBuffer nGlobalContactsOut, + int maxContactCapacity); +public static native int b3ContactConvexConvexSAT( + int pairIndex, + int bodyIndexA, int bodyIndexB, + int collidableIndexA, int collidableIndexB, + @Const @ByRef b3RigidBodyDataArray rigidBodies, + @Const @ByRef b3CollidableArray collidables, + @Const @ByRef b3ConvexPolyhedronDataArray convexShapes, + @Const @ByRef b3Vector3Array convexVertices, + @Const @ByRef b3Vector3Array uniqueEdges, + @Const @ByRef b3IntArray convexIndices, + @Const @ByRef b3GpuFaceArray faces, + @ByRef b3Contact4DataArray globalContactsOut, + @ByRef int[] nGlobalContactsOut, + int maxContactCapacity); + +// #endif //B3_CONTACT_CONVEX_CONVEX_SAT_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3FindSeparatingAxis.h + +// #ifndef B3_FIND_SEPARATING_AXIS_H +// #define B3_FIND_SEPARATING_AXIS_H + +public static native void b3ProjectAxis(@Const @ByRef b3ConvexPolyhedronData hull, @Const @ByRef b3Vector3 pos, @Const @ByRef b3Quaternion orn, @Const @ByRef b3Vector3 dir, @Const @ByRef b3Vector3Array vertices, @Cast("b3Scalar*") @ByRef FloatPointer min, @Cast("b3Scalar*") @ByRef FloatPointer max); +public static native void b3ProjectAxis(@Const @ByRef b3ConvexPolyhedronData hull, @Const @ByRef b3Vector3 pos, @Const @ByRef b3Quaternion orn, @Const @ByRef b3Vector3 dir, @Const @ByRef b3Vector3Array vertices, @Cast("b3Scalar*") @ByRef FloatBuffer min, @Cast("b3Scalar*") @ByRef FloatBuffer max); +public static native void b3ProjectAxis(@Const @ByRef b3ConvexPolyhedronData hull, @Const @ByRef b3Vector3 pos, @Const @ByRef b3Quaternion orn, @Const @ByRef b3Vector3 dir, @Const @ByRef b3Vector3Array vertices, @Cast("b3Scalar*") @ByRef float[] min, @Cast("b3Scalar*") @ByRef float[] max); + +public static native @Cast("bool") boolean b3TestSepAxis(@Const @ByRef b3ConvexPolyhedronData hullA, @Const @ByRef b3ConvexPolyhedronData hullB, + @Const @ByRef b3Vector3 posA, @Const @ByRef b3Quaternion ornA, + @Const @ByRef b3Vector3 posB, @Const @ByRef b3Quaternion ornB, + @Const @ByRef b3Vector3 sep_axis, @Const @ByRef b3Vector3Array verticesA, @Const @ByRef b3Vector3Array verticesB, @Cast("b3Scalar*") @ByRef FloatPointer depth); +public static native @Cast("bool") boolean b3TestSepAxis(@Const @ByRef b3ConvexPolyhedronData hullA, @Const @ByRef b3ConvexPolyhedronData hullB, + @Const @ByRef b3Vector3 posA, @Const @ByRef b3Quaternion ornA, + @Const @ByRef b3Vector3 posB, @Const @ByRef b3Quaternion ornB, + @Const @ByRef b3Vector3 sep_axis, @Const @ByRef b3Vector3Array verticesA, @Const @ByRef b3Vector3Array verticesB, @Cast("b3Scalar*") @ByRef FloatBuffer depth); +public static native @Cast("bool") boolean b3TestSepAxis(@Const @ByRef b3ConvexPolyhedronData hullA, @Const @ByRef b3ConvexPolyhedronData hullB, + @Const @ByRef b3Vector3 posA, @Const @ByRef b3Quaternion ornA, + @Const @ByRef b3Vector3 posB, @Const @ByRef b3Quaternion ornB, + @Const @ByRef b3Vector3 sep_axis, @Const @ByRef b3Vector3Array verticesA, @Const @ByRef b3Vector3Array verticesB, @Cast("b3Scalar*") @ByRef float[] depth); + +public static native @Cast("bool") boolean b3FindSeparatingAxis(@Const @ByRef b3ConvexPolyhedronData hullA, @Const @ByRef b3ConvexPolyhedronData hullB, + @Const @ByRef b3Vector3 posA1, + @Const @ByRef b3Quaternion ornA, + @Const @ByRef b3Vector3 posB1, + @Const @ByRef b3Quaternion ornB, + @Const @ByRef b3Vector3Array verticesA, + @Const @ByRef b3Vector3Array uniqueEdgesA, + @Const @ByRef b3GpuFaceArray facesA, + @Const @ByRef b3IntArray indicesA, + @Const @ByRef b3Vector3Array verticesB, + @Const @ByRef b3Vector3Array uniqueEdgesB, + @Const @ByRef b3GpuFaceArray facesB, + @Const @ByRef b3IntArray indicesB, + + @ByRef b3Vector3 sep); + +// #endif //B3_FIND_SEPARATING_AXIS_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3MprPenetration.h + + +/*** + * --------------------------------- + * Copyright (c)2012 Daniel Fiser + * + * This file was ported from mpr.c file, part of libccd. + * The Minkoski Portal Refinement implementation was ported + * to OpenCL by Erwin Coumans for the Bullet 3 Physics library. + * at http://github.com/erwincoumans/bullet3 + * + * Distributed under the OSI-approved BSD License (the "License"); + * see . + * This software is distributed WITHOUT ANY WARRANTY; without even the + * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the License for more information. + */ + +// #ifndef B3_MPR_PENETRATION_H +// #define B3_MPR_PENETRATION_H + +// #include "Bullet3Common/shared/b3PlatformDefinitions.h" +// #include "Bullet3Common/shared/b3Float4.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" + +// #ifdef __cplusplus +// #define B3_MPR_SQRT sqrtf +// #else +// #endif +// #define B3_MPR_FMIN(x, y) ((x) < (y) ? (x) : (y)) +// #define B3_MPR_FABS fabs + +public static final double B3_MPR_TOLERANCE = 1E-6f; +public static final int B3_MPR_MAX_ITERATIONS = 1000; +// Targeting ../Bullet3Collision/b3MprSupport_t.java + + +// Targeting ../Bullet3Collision/b3MprSimplex_t.java + + + +public static native b3MprSupport_t b3MprSimplexPointW(b3MprSimplex_t s, int idx); + +public static native void b3MprSimplexSetSize(b3MprSimplex_t s, int size); + +public static native int b3MprSimplexSize(@Const b3MprSimplex_t s); + +public static native @Const b3MprSupport_t b3MprSimplexPoint(@Const b3MprSimplex_t s, int idx); + +public static native void b3MprSupportCopy(b3MprSupport_t d, @Const b3MprSupport_t s); + +public static native void b3MprSimplexSet(b3MprSimplex_t s, @Cast("size_t") long pos, @Const b3MprSupport_t a); + +public static native void b3MprSimplexSwap(b3MprSimplex_t s, @Cast("size_t") long pos1, @Cast("size_t") long pos2); + +public static native int b3MprIsZero(float val); + +public static native int b3MprEq(float _a, float _b); + +public static native int b3MprVec3Eq(@Const b3Vector3 a, @Const b3Vector3 b); + +public static native @ByVal b3Vector3 b3LocalGetSupportVertex(@Const @ByRef b3Vector3 supportVec, @Const b3ConvexPolyhedronData hull, @Const b3Vector3 verticesA); + +public static native void b3MprConvexSupport(int pairIndex, int bodyIndex, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + @Const b3Vector3 _dir, b3Vector3 outp, int logme); + +public static native void b3MprSupport(int pairIndex, int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + @Const b3Vector3 _dir, b3MprSupport_t supp); + +public static native void b3FindOrigin(int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, b3MprSupport_t center); + +public static native void b3MprVec3Set(b3Vector3 v, float x, float y, float z); + +public static native void b3MprVec3Add(b3Vector3 v, @Const b3Vector3 w); + +public static native void b3MprVec3Copy(b3Vector3 v, @Const b3Vector3 w); + +public static native void b3MprVec3Scale(b3Vector3 d, float k); + +public static native float b3MprVec3Dot(@Const b3Vector3 a, @Const b3Vector3 b); + +public static native float b3MprVec3Len2(@Const b3Vector3 v); + +public static native void b3MprVec3Normalize(b3Vector3 d); + +public static native void b3MprVec3Cross(b3Vector3 d, @Const b3Vector3 a, @Const b3Vector3 b); + +public static native void b3MprVec3Sub2(b3Vector3 d, @Const b3Vector3 v, @Const b3Vector3 w); + +public static native void b3PortalDir(@Const b3MprSimplex_t portal, b3Vector3 dir); + +public static native int portalEncapsulesOrigin(@Const b3MprSimplex_t portal, + @Const b3Vector3 dir); + +public static native int portalReachTolerance(@Const b3MprSimplex_t portal, + @Const b3MprSupport_t v4, + @Const b3Vector3 dir); + +public static native int portalCanEncapsuleOrigin(@Const b3MprSimplex_t portal, + @Const b3MprSupport_t v4, + @Const b3Vector3 dir); + +public static native void b3ExpandPortal(b3MprSimplex_t portal, + @Const b3MprSupport_t v4); + +public static native int b3DiscoverPortal(int pairIndex, int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + IntPointer hasSepAxis, + b3MprSimplex_t portal); +public static native int b3DiscoverPortal(int pairIndex, int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + IntBuffer hasSepAxis, + b3MprSimplex_t portal); +public static native int b3DiscoverPortal(int pairIndex, int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + int[] hasSepAxis, + b3MprSimplex_t portal); + +public static native int b3RefinePortal(int pairIndex, int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + b3MprSimplex_t portal); + +public static native void b3FindPos(@Const b3MprSimplex_t portal, b3Vector3 pos); + +public static native float b3MprVec3Dist2(@Const b3Vector3 a, @Const b3Vector3 b); + +public static native float _b3MprVec3PointSegmentDist2(@Const b3Vector3 P, + @Const b3Vector3 x0, + @Const b3Vector3 b, + b3Vector3 witness); + +public static native float b3MprVec3PointTriDist2(@Const b3Vector3 P, + @Const b3Vector3 x0, @Const b3Vector3 B, + @Const b3Vector3 C, + b3Vector3 witness); + +public static native void b3FindPenetr(int pairIndex, int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + b3MprSimplex_t portal, + FloatPointer depth, b3Vector3 pdir, b3Vector3 pos); +public static native void b3FindPenetr(int pairIndex, int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + b3MprSimplex_t portal, + FloatBuffer depth, b3Vector3 pdir, b3Vector3 pos); +public static native void b3FindPenetr(int pairIndex, int bodyIndexA, int bodyIndexB, @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + b3MprSimplex_t portal, + float[] depth, b3Vector3 pdir, b3Vector3 pos); + +public static native void b3FindPenetrTouch(b3MprSimplex_t portal, FloatPointer depth, b3Vector3 dir, b3Vector3 pos); +public static native void b3FindPenetrTouch(b3MprSimplex_t portal, FloatBuffer depth, b3Vector3 dir, b3Vector3 pos); +public static native void b3FindPenetrTouch(b3MprSimplex_t portal, float[] depth, b3Vector3 dir, b3Vector3 pos); + +public static native void b3FindPenetrSegment(b3MprSimplex_t portal, + FloatPointer depth, b3Vector3 dir, b3Vector3 pos); +public static native void b3FindPenetrSegment(b3MprSimplex_t portal, + FloatBuffer depth, b3Vector3 dir, b3Vector3 pos); +public static native void b3FindPenetrSegment(b3MprSimplex_t portal, + float[] depth, b3Vector3 dir, b3Vector3 pos); + +public static native int b3MprPenetration(int pairIndex, int bodyIndexA, int bodyIndexB, + @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + IntPointer hasSepAxis, + FloatPointer depthOut, b3Vector3 dirOut, b3Vector3 posOut); +public static native int b3MprPenetration(int pairIndex, int bodyIndexA, int bodyIndexB, + @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + IntBuffer hasSepAxis, + FloatBuffer depthOut, b3Vector3 dirOut, b3Vector3 posOut); +public static native int b3MprPenetration(int pairIndex, int bodyIndexA, int bodyIndexB, + @Const b3RigidBodyData cpuBodyBuf, + @Const b3ConvexPolyhedronData cpuConvexData, + @Const b3Collidable cpuCollidables, + @Const b3Vector3 cpuVertices, + b3Vector3 sepAxis, + int[] hasSepAxis, + float[] depthOut, b3Vector3 dirOut, b3Vector3 posOut); + +// #endif //B3_MPR_PENETRATION_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h + + + +// #ifndef B3_QUANTIZED_BVH_NODE_H +// #define B3_QUANTIZED_BVH_NODE_H + +// #include "Bullet3Common/shared/b3Float4.h" + +public static final int B3_MAX_NUM_PARTS_IN_BITS = 10; +// Targeting ../Bullet3Collision/b3QuantizedBvhNodeData.java + + + +public static native int b3GetTriangleIndex(@Const b3QuantizedBvhNodeData rootNode); + +public static native int b3IsLeaf(@Const b3QuantizedBvhNodeData rootNode); + +public static native int b3GetEscapeIndex(@Const b3QuantizedBvhNodeData rootNode); + +public static native void b3QuantizeWithClamp(@Cast("unsigned short*") ShortPointer out, @Const @ByRef b3Vector3 point2, int isMax, @Const @ByRef b3Vector3 bvhAabbMin, @Const @ByRef b3Vector3 bvhAabbMax, @Const @ByRef b3Vector3 bvhQuantization); +public static native void b3QuantizeWithClamp(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef b3Vector3 point2, int isMax, @Const @ByRef b3Vector3 bvhAabbMin, @Const @ByRef b3Vector3 bvhAabbMax, @Const @ByRef b3Vector3 bvhQuantization); +public static native void b3QuantizeWithClamp(@Cast("unsigned short*") short[] out, @Const @ByRef b3Vector3 point2, int isMax, @Const @ByRef b3Vector3 bvhAabbMin, @Const @ByRef b3Vector3 bvhAabbMax, @Const @ByRef b3Vector3 bvhQuantization); + +public static native int b3TestQuantizedAabbAgainstQuantizedAabbSlow( + @Cast("const unsigned short int*") ShortPointer aabbMin1, + @Cast("const unsigned short int*") ShortPointer aabbMax1, + @Cast("const unsigned short int*") ShortPointer aabbMin2, + @Cast("const unsigned short int*") ShortPointer aabbMax2); +public static native int b3TestQuantizedAabbAgainstQuantizedAabbSlow( + @Cast("const unsigned short int*") ShortBuffer aabbMin1, + @Cast("const unsigned short int*") ShortBuffer aabbMax1, + @Cast("const unsigned short int*") ShortBuffer aabbMin2, + @Cast("const unsigned short int*") ShortBuffer aabbMax2); +public static native int b3TestQuantizedAabbAgainstQuantizedAabbSlow( + @Cast("const unsigned short int*") short[] aabbMin1, + @Cast("const unsigned short int*") short[] aabbMax1, + @Cast("const unsigned short int*") short[] aabbMin2, + @Cast("const unsigned short int*") short[] aabbMax2); + +// #endif //B3_QUANTIZED_BVH_NODE_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h + +// #ifndef B3_REDUCE_CONTACTS_H +// #define B3_REDUCE_CONTACTS_H + +public static native int b3ReduceContacts(@Const b3Vector3 p, int nPoints, @Const @ByRef b3Vector3 nearNormal, b3Int4 contactIdx); + +// #endif //B3_REDUCE_CONTACTS_H + + +// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3UpdateAabbs.h + +// #ifndef B3_UPDATE_AABBS_H +// #define B3_UPDATE_AABBS_H + +// #include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" + +public static native void b3ComputeWorldAabb(int bodyId, @Const b3RigidBodyData bodies, @Const b3Collidable collidables, @Const b3Aabb localShapeAABB, b3Aabb worldAabbs); + +// #endif //B3_UPDATE_AABBS_H + + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java index 19dfcc37a0e..92a04fe555e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java @@ -52,11 +52,16 @@ public class Bullet3Common extends org.bytedeco.bullet.presets.Bullet3Common { // #endif //B3_USE_MEMCPY // #ifdef B3_USE_PLACEMENT_NEW -// #include //for placement new -// #endif //B3_USE_PLACEMENT_NEW +// #include +// Targeting ../Bullet3Common/b3IntArray.java + + +// Targeting ../Bullet3Common/b3Int4Array.java + + +// Targeting ../Bullet3Common/b3Vector3Array.java + -/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ // #endif //B3_OBJECT_ARRAY__ @@ -1151,4 +1156,30 @@ B3_FORCE_INLINE b3Matrix3x3 b3MultTransposeLeft(const b3Matrix3x3& m1, const b3M // #endif //B3_MAT3x3_H +// Parsed from Bullet3Common/shared/b3PlatformDefinitions.h + +// #ifndef B3_PLATFORM_DEFINITIONS_H +// #define B3_PLATFORM_DEFINITIONS_H +// Targeting ../Bullet3Common/MyTest.java + + + +// #ifdef __cplusplus +//#define b3ConstArray(a) const b3AlignedObjectArray& +// #define b3ConstArray(a) const a * +// #define b3AtomicInc(a) ((*a)++) + +public static native int b3AtomicAdd(IntPointer p, int val); +public static native int b3AtomicAdd(IntBuffer p, int val); +public static native int b3AtomicAdd(int[] p, int val); + +// #define __global + +// #define B3_STATIC static +// #else +// #endif + +// #endif + + } From 87fd5d663622a8a6cc4c408ead08bc9e3e148626 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Fri, 4 Mar 2022 13:08:30 +0800 Subject: [PATCH 65/81] Mappings for Bullet3Dynamics library --- .../bullet/presets/Bullet3Collision.java | 10 +++ .../bullet/presets/Bullet3Common.java | 2 + .../bullet/presets/Bullet3Dynamics.java | 76 +++++++++++++++++++ bullet/src/main/java9/module-info.java | 1 + 4 files changed, 89 insertions(+) create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java index 80156635e4f..4fccbab676d 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java @@ -98,6 +98,8 @@ public void map(InfoMap infoMap) { .put(new Info("b3AlignedObjectArray").pointerTypes("b3GpuChildShapeArray")) .put(new Info("b3AlignedObjectArray").pointerTypes("b3GpuFaceArray")) .put(new Info("b3AlignedObjectArray").pointerTypes("b3MyFaceArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3RayHitArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3RayInfoArray")) .put(new Info("b3AlignedObjectArray").pointerTypes("b3RigidBodyDataArray")) .put(new Info("b3BvhSubtreeInfoData_t").pointerTypes("b3BvhSubtreeInfoData")) .put(new Info("b3Collidable_t").pointerTypes("b3Collidable")) @@ -154,6 +156,14 @@ public void map(InfoMap infoMap) { "b3AlignedObjectArray::findLinearSearch", "b3AlignedObjectArray::findLinearSearch2", "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", "b3AlignedObjectArray::findBinarySearch", "b3AlignedObjectArray::findLinearSearch", "b3AlignedObjectArray::findLinearSearch2", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java index 29092807963..8110b238eb9 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java @@ -86,6 +86,7 @@ public void map(InfoMap infoMap) { .put(new Info( "B3_STATIC", + "USE_SIMD", "b3Cross3", "b3Dot3F4", "b3Float4", @@ -96,6 +97,7 @@ public void map(InfoMap infoMap) { "b3Matrix3x3Data", "b3Quat", "b3QuatConstArg", + "b3SimdScalar", "b3TransformData", "b3Vector3Data" ).cppTypes().translate(false)) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java new file mode 100644 index 00000000000..4724aa6bcb7 --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java @@ -0,0 +1,76 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +/** + * + * @author Andrey Krainyak + */ +@Properties( + inherit = Bullet3Collision.class, + value = { + @Platform( + include = { + "Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h", + "Bullet3Dynamics/ConstraintSolver/b3SolverBody.h", + "Bullet3Dynamics/ConstraintSolver/b3SolverConstraint.h", + "Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h", + "Bullet3Dynamics/ConstraintSolver/b3FixedConstraint.h", + "Bullet3Dynamics/ConstraintSolver/b3Generic6DofConstraint.h", + "Bullet3Dynamics/ConstraintSolver/b3JacobianEntry.h", + "Bullet3Dynamics/ConstraintSolver/b3PgsJacobiSolver.h", + "Bullet3Dynamics/ConstraintSolver/b3Point2PointConstraint.h", + "Bullet3Dynamics/shared/b3ContactConstraint4.h", + "Bullet3Dynamics/shared/b3ConvertConstraint4.h", + "Bullet3Dynamics/shared/b3Inertia.h", + "Bullet3Dynamics/shared/b3IntegrateTransforms.h", + "Bullet3Dynamics/b3CpuRigidBodyPipeline.h", + }, + link = "Bullet3Dynamics@.3.20" + ) + }, + target = "org.bytedeco.bullet.Bullet3Dynamics", + global = "org.bytedeco.bullet.global.Bullet3Dynamics" +) +public class Bullet3Dynamics implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + public void map(InfoMap infoMap) { + infoMap + .put(new Info( + "IN_PARALLELL_SOLVER", + "b3Point2PointConstraintData" + ).cppTypes().translate(false)) + + .put(new Info("b3ContactConstraint4_t").pointerTypes("b3ContactConstraint4")) + ; + } +} diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 477bbb9d664..79782eb8142 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -8,4 +8,5 @@ exports org.bytedeco.bullet.BulletSoftBody; exports org.bytedeco.bullet.Bullet3Common; exports org.bytedeco.bullet.Bullet3Collision; + exports org.bytedeco.bullet.Bullet3Dynamics; } From 99b5bd5dcc3cb62fe8339de2dfaba347a51f8a38 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Fri, 4 Mar 2022 13:10:10 +0800 Subject: [PATCH 66/81] Update generated code for bullet's preset See parent commit. --- .../Bullet3Collision/b3RayHitArray.java | 87 +++ .../Bullet3Collision/b3RayInfoArray.java | 87 +++ .../Bullet3Dynamics/b3AngularLimit.java | 88 ++++ .../Bullet3Dynamics/b3ConstraintSetting.java | 39 ++ .../Bullet3Dynamics/b3ContactConstraint4.java | 55 ++ .../Bullet3Dynamics/b3ContactPoint.java | 23 + .../Bullet3Dynamics/b3ContactSolverInfo.java | 35 ++ .../b3ContactSolverInfoData.java | 58 ++ .../b3ContactSolverInfoDoubleData.java | 61 +++ .../b3ContactSolverInfoFloatData.java | 64 +++ .../b3CpuRigidBodyPipeline.java | 62 +++ .../bullet/Bullet3Dynamics/b3Dispatcher.java | 24 + .../Bullet3Dynamics/b3FixedConstraint.java | 35 ++ .../b3Generic6DofConstraint.java | 179 +++++++ .../bullet/Bullet3Dynamics/b3Inertia.java | 38 ++ .../Bullet3Dynamics/b3JacobianEntry.java | 117 ++++ .../Bullet3Dynamics/b3JointFeedback.java | 41 ++ .../Bullet3Dynamics/b3PgsJacobiSolver.java | 44 ++ .../b3Point2PointConstraint.java | 63 +++ .../b3Point2PointConstraintDoubleData.java | 40 ++ .../b3Point2PointConstraintFloatData.java | 40 ++ .../bullet/Bullet3Dynamics/b3RigidBody.java | 24 + .../b3RotationalLimitMotor.java | 90 ++++ .../bullet/Bullet3Dynamics/b3Serializer.java | 24 + .../bullet/Bullet3Dynamics/b3SolverBody.java | 102 ++++ .../Bullet3Dynamics/b3SolverConstraint.java | 71 +++ .../b3TranslationalLimitMotor.java | 89 ++++ .../Bullet3Dynamics/b3TypedConstraint.java | 183 +++++++ .../b3TypedConstraintData.java | 56 ++ .../bullet/global/Bullet3Collision.java | 6 + .../bullet/global/Bullet3Dynamics.java | 498 ++++++++++++++++++ 31 files changed, 2423 insertions(+) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayHitArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayInfoArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3AngularLimit.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ConstraintSetting.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactConstraint4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactPoint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Dispatcher.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3FixedConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Generic6DofConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Inertia.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3JacobianEntry.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3JointFeedback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3PgsJacobiSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraintDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraintFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RigidBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RotationalLimitMotor.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Serializer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3SolverBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3SolverConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TranslationalLimitMotor.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraintData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayHitArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayHitArray.java new file mode 100644 index 00000000000..5d3da5c9242 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayHitArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3RayHitArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RayHitArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3RayHitArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3RayHitArray position(long position) { + return (b3RayHitArray)super.position(position); + } + @Override public b3RayHitArray getPointer(long i) { + return new b3RayHitArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3RayHitArray put(@Const @ByRef b3RayHitArray other); + public b3RayHitArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3RayHitArray(@Const @ByRef b3RayHitArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3RayHitArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3RayHit at(int n); + + public native @ByRef @Name("operator []") b3RayHit get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3RayHit()") b3RayHit fillData); + public native void resize(int newsize); + public native @ByRef b3RayHit expandNonInitializing(); + + public native @ByRef b3RayHit expand(@Const @ByRef(nullValue = "b3RayHit()") b3RayHit fillValue); + public native @ByRef b3RayHit expand(); + + public native void push_back(@Const @ByRef b3RayHit _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3RayHitArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayInfoArray.java new file mode 100644 index 00000000000..d8dfd22662a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3RayInfoArray.java @@ -0,0 +1,87 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Collision; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; + +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) +public class b3RayInfoArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RayInfoArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3RayInfoArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3RayInfoArray position(long position) { + return (b3RayInfoArray)super.position(position); + } + @Override public b3RayInfoArray getPointer(long i) { + return new b3RayInfoArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3RayInfoArray put(@Const @ByRef b3RayInfoArray other); + public b3RayInfoArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3RayInfoArray(@Const @ByRef b3RayInfoArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3RayInfoArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3RayInfo at(int n); + + public native @ByRef @Name("operator []") b3RayInfo get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3RayInfo()") b3RayInfo fillData); + public native void resize(int newsize); + public native @ByRef b3RayInfo expandNonInitializing(); + + public native @ByRef b3RayInfo expand(@Const @ByRef(nullValue = "b3RayInfo()") b3RayInfo fillValue); + public native @ByRef b3RayInfo expand(); + + public native void push_back(@Const @ByRef b3RayInfo _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3RayInfoArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3AngularLimit.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3AngularLimit.java new file mode 100644 index 00000000000..15c8831ee28 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3AngularLimit.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +// clang-format on + +/*B3_FORCE_INLINE int b3TypedConstraint::calculateSerializeBufferSize() const +{ + return sizeof(b3TypedConstraintData); +} +*/ + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3AngularLimit extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3AngularLimit(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3AngularLimit(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3AngularLimit position(long position) { + return (b3AngularLimit)super.position(position); + } + @Override public b3AngularLimit getPointer(long i) { + return new b3AngularLimit((Pointer)this).offsetAddress(i); + } + + /** Default constructor initializes limit as inactive, allowing free constraint movement */ + public b3AngularLimit() { super((Pointer)null); allocate(); } + private native void allocate(); + + /** Sets all limit's parameters. + * When low > high limit becomes inactive. + * When high - low > 2PI limit is ineffective too becouse no angle can exceed the limit */ + public native void set(@Cast("b3Scalar") float low, @Cast("b3Scalar") float high, @Cast("b3Scalar") float _softness/*=0.9f*/, @Cast("b3Scalar") float _biasFactor/*=0.3f*/, @Cast("b3Scalar") float _relaxationFactor/*=1.0f*/); + public native void set(@Cast("b3Scalar") float low, @Cast("b3Scalar") float high); + + /** Checks conastaint angle against limit. If limit is active and the angle violates the limit + * correction is calculated. */ + public native void test(@Cast("const b3Scalar") float angle); + + /** Returns limit's softness */ + public native @Cast("b3Scalar") float getSoftness(); + + /** Returns limit's bias factor */ + public native @Cast("b3Scalar") float getBiasFactor(); + + /** Returns limit's relaxation factor */ + public native @Cast("b3Scalar") float getRelaxationFactor(); + + /** Returns correction value evaluated when test() was invoked */ + public native @Cast("b3Scalar") float getCorrection(); + + /** Returns sign value evaluated when test() was invoked */ + public native @Cast("b3Scalar") float getSign(); + + /** Gives half of the distance between min and max limit angle */ + public native @Cast("b3Scalar") float getHalfRange(); + + /** Returns true when the last test() invocation recognized limit violation */ + public native @Cast("bool") boolean isLimit(); + + /** Checks given angle against limit. If limit is active and angle doesn't fit it, the angle + * returned is modified so it equals to the limit closest to given angle. */ + public native void fit(@Cast("b3Scalar*") @ByRef FloatPointer angle); + public native void fit(@Cast("b3Scalar*") @ByRef FloatBuffer angle); + public native void fit(@Cast("b3Scalar*") @ByRef float[] angle); + + /** Returns correction value multiplied by sign value */ + public native @Cast("b3Scalar") float getError(); + + public native @Cast("b3Scalar") float getLow(); + + public native @Cast("b3Scalar") float getHigh(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ConstraintSetting.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ConstraintSetting.java new file mode 100644 index 00000000000..1baa4292abe --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ConstraintSetting.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +// #endif //B3_USE_DOUBLE_PRECISION + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3ConstraintSetting extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConstraintSetting(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConstraintSetting(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3ConstraintSetting position(long position) { + return (b3ConstraintSetting)super.position(position); + } + @Override public b3ConstraintSetting getPointer(long i) { + return new b3ConstraintSetting((Pointer)this).offsetAddress(i); + } + + public b3ConstraintSetting() { super((Pointer)null); allocate(); } + private native void allocate(); + public native @Cast("b3Scalar") float m_tau(); public native b3ConstraintSetting m_tau(float setter); + public native @Cast("b3Scalar") float m_damping(); public native b3ConstraintSetting m_damping(float setter); + public native @Cast("b3Scalar") float m_impulseClamp(); public native b3ConstraintSetting m_impulseClamp(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactConstraint4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactConstraint4.java new file mode 100644 index 00000000000..0cba0773dc5 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactConstraint4.java @@ -0,0 +1,55 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3ContactConstraint4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ContactConstraint4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ContactConstraint4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ContactConstraint4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ContactConstraint4 position(long position) { + return (b3ContactConstraint4)super.position(position); + } + @Override public b3ContactConstraint4 getPointer(long i) { + return new b3ContactConstraint4((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_linear(); public native b3ContactConstraint4 m_linear(b3Vector3 setter); //normal? + public native @ByRef b3Vector3 m_worldPos(int i); public native b3ContactConstraint4 m_worldPos(int i, b3Vector3 setter); + @MemberGetter public native b3Vector3 m_worldPos(); + public native @ByRef b3Vector3 m_center(); public native b3ContactConstraint4 m_center(b3Vector3 setter); // friction + public native float m_jacCoeffInv(int i); public native b3ContactConstraint4 m_jacCoeffInv(int i, float setter); + @MemberGetter public native FloatPointer m_jacCoeffInv(); + public native float m_b(int i); public native b3ContactConstraint4 m_b(int i, float setter); + @MemberGetter public native FloatPointer m_b(); + public native float m_appliedRambdaDt(int i); public native b3ContactConstraint4 m_appliedRambdaDt(int i, float setter); + @MemberGetter public native FloatPointer m_appliedRambdaDt(); + public native float m_fJacCoeffInv(int i); public native b3ContactConstraint4 m_fJacCoeffInv(int i, float setter); + @MemberGetter public native FloatPointer m_fJacCoeffInv(); // friction + public native float m_fAppliedRambdaDt(int i); public native b3ContactConstraint4 m_fAppliedRambdaDt(int i, float setter); + @MemberGetter public native FloatPointer m_fAppliedRambdaDt(); // friction + + public native @Cast("unsigned int") int m_bodyA(); public native b3ContactConstraint4 m_bodyA(int setter); + public native @Cast("unsigned int") int m_bodyB(); public native b3ContactConstraint4 m_bodyB(int setter); + public native int m_batchIdx(); public native b3ContactConstraint4 m_batchIdx(int setter); + public native @Cast("unsigned int") int m_paddings(); public native b3ContactConstraint4 m_paddings(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactPoint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactPoint.java new file mode 100644 index 00000000000..1e6eef6ad46 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactPoint.java @@ -0,0 +1,23 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3ContactPoint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3ContactPoint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ContactPoint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfo.java new file mode 100644 index 00000000000..66758b06150 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfo.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3ContactSolverInfo extends b3ContactSolverInfoData { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ContactSolverInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ContactSolverInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3ContactSolverInfo position(long position) { + return (b3ContactSolverInfo)super.position(position); + } + @Override public b3ContactSolverInfo getPointer(long i) { + return new b3ContactSolverInfo((Pointer)this).offsetAddress(i); + } + + public b3ContactSolverInfo() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoData.java new file mode 100644 index 00000000000..f39b4b27a0f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoData.java @@ -0,0 +1,58 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3ContactSolverInfoData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ContactSolverInfoData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ContactSolverInfoData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ContactSolverInfoData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ContactSolverInfoData position(long position) { + return (b3ContactSolverInfoData)super.position(position); + } + @Override public b3ContactSolverInfoData getPointer(long i) { + return new b3ContactSolverInfoData((Pointer)this).offsetAddress(i); + } + + public native @Cast("b3Scalar") float m_tau(); public native b3ContactSolverInfoData m_tau(float setter); + public native @Cast("b3Scalar") float m_damping(); public native b3ContactSolverInfoData m_damping(float setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native @Cast("b3Scalar") float m_friction(); public native b3ContactSolverInfoData m_friction(float setter); + public native @Cast("b3Scalar") float m_timeStep(); public native b3ContactSolverInfoData m_timeStep(float setter); + public native @Cast("b3Scalar") float m_restitution(); public native b3ContactSolverInfoData m_restitution(float setter); + public native int m_numIterations(); public native b3ContactSolverInfoData m_numIterations(int setter); + public native @Cast("b3Scalar") float m_maxErrorReduction(); public native b3ContactSolverInfoData m_maxErrorReduction(float setter); + public native @Cast("b3Scalar") float m_sor(); public native b3ContactSolverInfoData m_sor(float setter); + public native @Cast("b3Scalar") float m_erp(); public native b3ContactSolverInfoData m_erp(float setter); //used as Baumgarte factor + public native @Cast("b3Scalar") float m_erp2(); public native b3ContactSolverInfoData m_erp2(float setter); //used in Split Impulse + public native @Cast("b3Scalar") float m_globalCfm(); public native b3ContactSolverInfoData m_globalCfm(float setter); //constraint force mixing + public native int m_splitImpulse(); public native b3ContactSolverInfoData m_splitImpulse(int setter); + public native @Cast("b3Scalar") float m_splitImpulsePenetrationThreshold(); public native b3ContactSolverInfoData m_splitImpulsePenetrationThreshold(float setter); + public native @Cast("b3Scalar") float m_splitImpulseTurnErp(); public native b3ContactSolverInfoData m_splitImpulseTurnErp(float setter); + public native @Cast("b3Scalar") float m_linearSlop(); public native b3ContactSolverInfoData m_linearSlop(float setter); + public native @Cast("b3Scalar") float m_warmstartingFactor(); public native b3ContactSolverInfoData m_warmstartingFactor(float setter); + + public native int m_solverMode(); public native b3ContactSolverInfoData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native b3ContactSolverInfoData m_restingContactRestitutionThreshold(int setter); + public native int m_minimumSolverBatchSize(); public native b3ContactSolverInfoData m_minimumSolverBatchSize(int setter); + public native @Cast("b3Scalar") float m_maxGyroscopicForce(); public native b3ContactSolverInfoData m_maxGyroscopicForce(float setter); + public native @Cast("b3Scalar") float m_singleAxisRollingFrictionThreshold(); public native b3ContactSolverInfoData m_singleAxisRollingFrictionThreshold(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoDoubleData.java new file mode 100644 index 00000000000..7c2e611ce1f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoDoubleData.java @@ -0,0 +1,61 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3ContactSolverInfoDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ContactSolverInfoDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ContactSolverInfoDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ContactSolverInfoDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ContactSolverInfoDoubleData position(long position) { + return (b3ContactSolverInfoDoubleData)super.position(position); + } + @Override public b3ContactSolverInfoDoubleData getPointer(long i) { + return new b3ContactSolverInfoDoubleData((Pointer)this).offsetAddress(i); + } + + public native double m_tau(); public native b3ContactSolverInfoDoubleData m_tau(double setter); + public native double m_damping(); public native b3ContactSolverInfoDoubleData m_damping(double setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native double m_friction(); public native b3ContactSolverInfoDoubleData m_friction(double setter); + public native double m_timeStep(); public native b3ContactSolverInfoDoubleData m_timeStep(double setter); + public native double m_restitution(); public native b3ContactSolverInfoDoubleData m_restitution(double setter); + public native double m_maxErrorReduction(); public native b3ContactSolverInfoDoubleData m_maxErrorReduction(double setter); + public native double m_sor(); public native b3ContactSolverInfoDoubleData m_sor(double setter); + public native double m_erp(); public native b3ContactSolverInfoDoubleData m_erp(double setter); //used as Baumgarte factor + public native double m_erp2(); public native b3ContactSolverInfoDoubleData m_erp2(double setter); //used in Split Impulse + public native double m_globalCfm(); public native b3ContactSolverInfoDoubleData m_globalCfm(double setter); //constraint force mixing + public native double m_splitImpulsePenetrationThreshold(); public native b3ContactSolverInfoDoubleData m_splitImpulsePenetrationThreshold(double setter); + public native double m_splitImpulseTurnErp(); public native b3ContactSolverInfoDoubleData m_splitImpulseTurnErp(double setter); + public native double m_linearSlop(); public native b3ContactSolverInfoDoubleData m_linearSlop(double setter); + public native double m_warmstartingFactor(); public native b3ContactSolverInfoDoubleData m_warmstartingFactor(double setter); + public native double m_maxGyroscopicForce(); public native b3ContactSolverInfoDoubleData m_maxGyroscopicForce(double setter); + public native double m_singleAxisRollingFrictionThreshold(); public native b3ContactSolverInfoDoubleData m_singleAxisRollingFrictionThreshold(double setter); + + public native int m_numIterations(); public native b3ContactSolverInfoDoubleData m_numIterations(int setter); + public native int m_solverMode(); public native b3ContactSolverInfoDoubleData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native b3ContactSolverInfoDoubleData m_restingContactRestitutionThreshold(int setter); + public native int m_minimumSolverBatchSize(); public native b3ContactSolverInfoDoubleData m_minimumSolverBatchSize(int setter); + public native int m_splitImpulse(); public native b3ContactSolverInfoDoubleData m_splitImpulse(int setter); + public native @Cast("char") byte m_padding(int i); public native b3ContactSolverInfoDoubleData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoFloatData.java new file mode 100644 index 00000000000..904ef2ff53e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3ContactSolverInfoFloatData.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3ContactSolverInfoFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ContactSolverInfoFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ContactSolverInfoFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ContactSolverInfoFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ContactSolverInfoFloatData position(long position) { + return (b3ContactSolverInfoFloatData)super.position(position); + } + @Override public b3ContactSolverInfoFloatData getPointer(long i) { + return new b3ContactSolverInfoFloatData((Pointer)this).offsetAddress(i); + } + + public native float m_tau(); public native b3ContactSolverInfoFloatData m_tau(float setter); + public native float m_damping(); public native b3ContactSolverInfoFloatData m_damping(float setter); //global non-contact constraint damping, can be locally overridden by constraints during 'getInfo2'. + public native float m_friction(); public native b3ContactSolverInfoFloatData m_friction(float setter); + public native float m_timeStep(); public native b3ContactSolverInfoFloatData m_timeStep(float setter); + + public native float m_restitution(); public native b3ContactSolverInfoFloatData m_restitution(float setter); + public native float m_maxErrorReduction(); public native b3ContactSolverInfoFloatData m_maxErrorReduction(float setter); + public native float m_sor(); public native b3ContactSolverInfoFloatData m_sor(float setter); + public native float m_erp(); public native b3ContactSolverInfoFloatData m_erp(float setter); //used as Baumgarte factor + + public native float m_erp2(); public native b3ContactSolverInfoFloatData m_erp2(float setter); //used in Split Impulse + public native float m_globalCfm(); public native b3ContactSolverInfoFloatData m_globalCfm(float setter); //constraint force mixing + public native float m_splitImpulsePenetrationThreshold(); public native b3ContactSolverInfoFloatData m_splitImpulsePenetrationThreshold(float setter); + public native float m_splitImpulseTurnErp(); public native b3ContactSolverInfoFloatData m_splitImpulseTurnErp(float setter); + + public native float m_linearSlop(); public native b3ContactSolverInfoFloatData m_linearSlop(float setter); + public native float m_warmstartingFactor(); public native b3ContactSolverInfoFloatData m_warmstartingFactor(float setter); + public native float m_maxGyroscopicForce(); public native b3ContactSolverInfoFloatData m_maxGyroscopicForce(float setter); + public native float m_singleAxisRollingFrictionThreshold(); public native b3ContactSolverInfoFloatData m_singleAxisRollingFrictionThreshold(float setter); + + public native int m_numIterations(); public native b3ContactSolverInfoFloatData m_numIterations(int setter); + public native int m_solverMode(); public native b3ContactSolverInfoFloatData m_solverMode(int setter); + public native int m_restingContactRestitutionThreshold(); public native b3ContactSolverInfoFloatData m_restingContactRestitutionThreshold(int setter); + public native int m_minimumSolverBatchSize(); public native b3ContactSolverInfoFloatData m_minimumSolverBatchSize(int setter); + + public native int m_splitImpulse(); public native b3ContactSolverInfoFloatData m_splitImpulse(int setter); + public native @Cast("char") byte m_padding(int i); public native b3ContactSolverInfoFloatData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.java new file mode 100644 index 00000000000..1730b03a8cb --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3CpuRigidBodyPipeline extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CpuRigidBodyPipeline(Pointer p) { super(p); } + + public b3CpuRigidBodyPipeline(b3CpuNarrowPhase narrowphase, b3DynamicBvhBroadphase broadphaseDbvt, @Const @ByRef b3Config config) { super((Pointer)null); allocate(narrowphase, broadphaseDbvt, config); } + private native void allocate(b3CpuNarrowPhase narrowphase, b3DynamicBvhBroadphase broadphaseDbvt, @Const @ByRef b3Config config); + + public native void stepSimulation(float deltaTime); + public native void integrate(float timeStep); + public native void updateAabbWorldSpace(); + public native void computeOverlappingPairs(); + public native void computeContactPoints(); + public native void solveContactConstraints(); + + public native int registerConvexPolyhedron(b3ConvexUtility convex); + + public native int registerPhysicsInstance(float mass, @Const FloatPointer _position, @Const FloatPointer orientation, int collisionShapeIndex, int userData); + public native int registerPhysicsInstance(float mass, @Const FloatBuffer _position, @Const FloatBuffer orientation, int collisionShapeIndex, int userData); + public native int registerPhysicsInstance(float mass, @Const float[] _position, @Const float[] orientation, int collisionShapeIndex, int userData); + public native void writeAllInstancesToGpu(); + public native void copyConstraintsToHost(); + public native void setGravity(@Const FloatPointer grav); + public native void setGravity(@Const FloatBuffer grav); + public native void setGravity(@Const float[] grav); + public native void reset(); + + public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const FloatPointer pivotInA, @Const FloatPointer pivotInB, float breakingThreshold); + public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const FloatBuffer pivotInA, @Const FloatBuffer pivotInB, float breakingThreshold); + public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const float[] pivotInA, @Const float[] pivotInB, float breakingThreshold); + public native int createFixedConstraint(int bodyA, int bodyB, @Const FloatPointer pivotInA, @Const FloatPointer pivotInB, @Const FloatPointer relTargetAB, float breakingThreshold); + public native int createFixedConstraint(int bodyA, int bodyB, @Const FloatBuffer pivotInA, @Const FloatBuffer pivotInB, @Const FloatBuffer relTargetAB, float breakingThreshold); + public native int createFixedConstraint(int bodyA, int bodyB, @Const float[] pivotInA, @Const float[] pivotInB, @Const float[] relTargetAB, float breakingThreshold); + public native void removeConstraintByUid(int uid); + + public native void addConstraint(b3TypedConstraint constraint); + public native void removeConstraint(b3TypedConstraint constraint); + + public native void castRays(@Const @ByRef b3RayInfoArray rays, @ByRef b3RayHitArray hitResults); + + public native @Const b3RigidBodyData getBodyBuffer(); + + public native int getNumBodies(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Dispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Dispatcher.java new file mode 100644 index 00000000000..4b912888975 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Dispatcher.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3Dispatcher extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3Dispatcher() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Dispatcher(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3FixedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3FixedConstraint.java new file mode 100644 index 00000000000..052b82d55b2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3FixedConstraint.java @@ -0,0 +1,35 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3FixedConstraint extends b3TypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3FixedConstraint(Pointer p) { super(p); } + + public b3FixedConstraint(int rbA, int rbB, @Const @ByRef b3Transform frameInA, @Const @ByRef b3Transform frameInB) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB); } + private native void allocate(int rbA, int rbB, @Const @ByRef b3Transform frameInA, @Const @ByRef b3Transform frameInB); + + public native void getInfo1(b3ConstraintInfo1 info, @Const b3RigidBodyData bodies); + + public native void getInfo2(b3ConstraintInfo2 info, @Const b3RigidBodyData bodies); + + public native void setParam(int num, @Cast("b3Scalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("b3Scalar") float value); + public native @Cast("b3Scalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("b3Scalar") float getParam(int num); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Generic6DofConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Generic6DofConstraint.java new file mode 100644 index 00000000000..8b9fdc35c85 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Generic6DofConstraint.java @@ -0,0 +1,179 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + // bits per axis + +/** b3Generic6DofConstraint between two rigidbodies each with a pivotpoint that descibes the axis location in local space +/** +b3Generic6DofConstraint can leave any of the 6 degree of freedom 'free' or 'locked'. +currently this limit supports rotational motors
+

+

+*/ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3Generic6DofConstraint extends b3TypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Generic6DofConstraint(Pointer p) { super(p); } + + + public b3Generic6DofConstraint(int rbA, int rbB, @Const @ByRef b3Transform frameInA, @Const @ByRef b3Transform frameInB, @Cast("bool") boolean useLinearReferenceFrameA, @Const b3RigidBodyData bodies) { super((Pointer)null); allocate(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA, bodies); } + private native void allocate(int rbA, int rbB, @Const @ByRef b3Transform frameInA, @Const @ByRef b3Transform frameInB, @Cast("bool") boolean useLinearReferenceFrameA, @Const b3RigidBodyData bodies); + + /** Calcs global transform of the offsets + /** + Calcs the global transform for the joint offset for body A an B, and also calcs the agle differences between the bodies. + @see b3Generic6DofConstraint.getCalculatedTransformA , b3Generic6DofConstraint.getCalculatedTransformB, b3Generic6DofConstraint.calculateAngleInfo + */ + public native void calculateTransforms(@Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB, @Const b3RigidBodyData bodies); + + public native void calculateTransforms(@Const b3RigidBodyData bodies); + + /** Gets the global transform of the offset for body A + /** + @see b3Generic6DofConstraint.getFrameOffsetA, b3Generic6DofConstraint.getFrameOffsetB, b3Generic6DofConstraint.calculateAngleInfo. + */ + public native @Const @ByRef b3Transform getCalculatedTransformA(); + + /** Gets the global transform of the offset for body B + /** + @see b3Generic6DofConstraint.getFrameOffsetA, b3Generic6DofConstraint.getFrameOffsetB, b3Generic6DofConstraint.calculateAngleInfo. + */ + public native @Const @ByRef b3Transform getCalculatedTransformB(); + + public native @ByRef b3Transform getFrameOffsetA(); + + public native @ByRef b3Transform getFrameOffsetB(); + + public native void getInfo1(b3ConstraintInfo1 info, @Const b3RigidBodyData bodies); + + public native void getInfo1NonVirtual(b3ConstraintInfo1 info, @Const b3RigidBodyData bodies); + + public native void getInfo2(b3ConstraintInfo2 info, @Const b3RigidBodyData bodies); + + public native void getInfo2NonVirtual(b3ConstraintInfo2 info, @Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB, @Const @ByRef b3Vector3 linVelA, @Const @ByRef b3Vector3 linVelB, @Const @ByRef b3Vector3 angVelA, @Const @ByRef b3Vector3 angVelB, @Const b3RigidBodyData bodies); + + public native void updateRHS(@Cast("b3Scalar") float timeStep); + + /** Get the rotation axis in global coordinates */ + public native @ByVal b3Vector3 getAxis(int axis_index); + + /** Get the relative Euler angle + /** + \pre b3Generic6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("b3Scalar") float getAngle(int axis_index); + + /** Get the relative position of the constraint pivot + /** + \pre b3Generic6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("b3Scalar") float getRelativePivotPosition(int axis_index); + + public native void setFrames(@Const @ByRef b3Transform frameA, @Const @ByRef b3Transform frameB, @Const b3RigidBodyData bodies); + + /** Test angular limit. + /** + Calculates angular correction and returns true if limit needs to be corrected. + \pre b3Generic6DofConstraint::calculateTransforms() must be called previously. + */ + public native @Cast("bool") boolean testAngularLimitMotor(int axis_index); + + public native void setLinearLowerLimit(@Const @ByRef b3Vector3 linearLower); + + public native void getLinearLowerLimit(@ByRef b3Vector3 linearLower); + + public native void setLinearUpperLimit(@Const @ByRef b3Vector3 linearUpper); + + public native void getLinearUpperLimit(@ByRef b3Vector3 linearUpper); + + public native void setAngularLowerLimit(@Const @ByRef b3Vector3 angularLower); + + public native void getAngularLowerLimit(@ByRef b3Vector3 angularLower); + + public native void setAngularUpperLimit(@Const @ByRef b3Vector3 angularUpper); + + public native void getAngularUpperLimit(@ByRef b3Vector3 angularUpper); + + /** Retrieves the angular limit informacion */ + public native b3RotationalLimitMotor getRotationalLimitMotor(int index); + + /** Retrieves the limit informacion */ + public native b3TranslationalLimitMotor getTranslationalLimitMotor(); + + //first 3 are linear, next 3 are angular + public native void setLimit(int axis, @Cast("b3Scalar") float lo, @Cast("b3Scalar") float hi); + + /** Test limit + /** + - free means upper < lower, + - locked means upper == lower + - limited means upper > lower + - limitIndex: first 3 are linear, next 3 are angular + */ + public native @Cast("bool") boolean isLimited(int limitIndex); + + public native void calcAnchorPos(@Const b3RigidBodyData bodies); // overridable + + public native int get_limit_motor_info2(b3RotationalLimitMotor limot, + @Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB, @Const @ByRef b3Vector3 linVelA, @Const @ByRef b3Vector3 linVelB, @Const @ByRef b3Vector3 angVelA, @Const @ByRef b3Vector3 angVelB, + b3ConstraintInfo2 info, int row, @ByRef b3Vector3 ax1, int rotational, int rotAllowed/*=false*/); + public native int get_limit_motor_info2(b3RotationalLimitMotor limot, + @Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB, @Const @ByRef b3Vector3 linVelA, @Const @ByRef b3Vector3 linVelB, @Const @ByRef b3Vector3 angVelA, @Const @ByRef b3Vector3 angVelB, + b3ConstraintInfo2 info, int row, @ByRef b3Vector3 ax1, int rotational); + + // access for UseFrameOffset + public native @Cast("bool") boolean getUseFrameOffset(); + public native void setUseFrameOffset(@Cast("bool") boolean frameOffsetOnOff); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("b3Scalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("b3Scalar") float value); + /**return the local value of parameter */ + public native @Cast("b3Scalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("b3Scalar") float getParam(int num); + + public native void setAxis(@Const @ByRef b3Vector3 axis1, @Const @ByRef b3Vector3 axis2, @Const b3RigidBodyData bodies); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Inertia.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Inertia.java new file mode 100644 index 00000000000..c4e6797309c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Inertia.java @@ -0,0 +1,38 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3Inertia extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Inertia() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Inertia(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Inertia(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Inertia position(long position) { + return (b3Inertia)super.position(position); + } + @Override public b3Inertia getPointer(long i) { + return new b3Inertia((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Matrix3x3 m_invInertiaWorld(); public native b3Inertia m_invInertiaWorld(b3Matrix3x3 setter); + public native @ByRef b3Matrix3x3 m_initInvInertia(); public native b3Inertia m_initInvInertia(b3Matrix3x3 setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3JacobianEntry.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3JacobianEntry.java new file mode 100644 index 00000000000..09bfd8937c6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3JacobianEntry.java @@ -0,0 +1,117 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +//notes: +// Another memory optimization would be to store m_1MinvJt in the remaining 3 w components +// which makes the b3JacobianEntry memory layout 16 bytes +// if you only are interested in angular part, just feed massInvA and massInvB zero + +/** Jacobian entry is an abstraction that allows to describe constraints + * it can be used in combination with a constraint solver + * Can be used to relate the effect of an impulse to the constraint error */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3JacobianEntry extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3JacobianEntry(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3JacobianEntry(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3JacobianEntry position(long position) { + return (b3JacobianEntry)super.position(position); + } + @Override public b3JacobianEntry getPointer(long i) { + return new b3JacobianEntry((Pointer)this).offsetAddress(i); + } + + public b3JacobianEntry() { super((Pointer)null); allocate(); } + private native void allocate(); + //constraint between two different rigidbodies + public b3JacobianEntry( + @Const @ByRef b3Matrix3x3 world2A, + @Const @ByRef b3Matrix3x3 world2B, + @Const @ByRef b3Vector3 rel_pos1, @Const @ByRef b3Vector3 rel_pos2, + @Const @ByRef b3Vector3 jointAxis, + @Const @ByRef b3Vector3 inertiaInvA, + @Cast("const b3Scalar") float massInvA, + @Const @ByRef b3Vector3 inertiaInvB, + @Cast("const b3Scalar") float massInvB) { super((Pointer)null); allocate(world2A, world2B, rel_pos1, rel_pos2, jointAxis, inertiaInvA, massInvA, inertiaInvB, massInvB); } + private native void allocate( + @Const @ByRef b3Matrix3x3 world2A, + @Const @ByRef b3Matrix3x3 world2B, + @Const @ByRef b3Vector3 rel_pos1, @Const @ByRef b3Vector3 rel_pos2, + @Const @ByRef b3Vector3 jointAxis, + @Const @ByRef b3Vector3 inertiaInvA, + @Cast("const b3Scalar") float massInvA, + @Const @ByRef b3Vector3 inertiaInvB, + @Cast("const b3Scalar") float massInvB); + + //angular constraint between two different rigidbodies + public b3JacobianEntry(@Const @ByRef b3Vector3 jointAxis, + @Const @ByRef b3Matrix3x3 world2A, + @Const @ByRef b3Matrix3x3 world2B, + @Const @ByRef b3Vector3 inertiaInvA, + @Const @ByRef b3Vector3 inertiaInvB) { super((Pointer)null); allocate(jointAxis, world2A, world2B, inertiaInvA, inertiaInvB); } + private native void allocate(@Const @ByRef b3Vector3 jointAxis, + @Const @ByRef b3Matrix3x3 world2A, + @Const @ByRef b3Matrix3x3 world2B, + @Const @ByRef b3Vector3 inertiaInvA, + @Const @ByRef b3Vector3 inertiaInvB); + + //angular constraint between two different rigidbodies + public b3JacobianEntry(@Const @ByRef b3Vector3 axisInA, + @Const @ByRef b3Vector3 axisInB, + @Const @ByRef b3Vector3 inertiaInvA, + @Const @ByRef b3Vector3 inertiaInvB) { super((Pointer)null); allocate(axisInA, axisInB, inertiaInvA, inertiaInvB); } + private native void allocate(@Const @ByRef b3Vector3 axisInA, + @Const @ByRef b3Vector3 axisInB, + @Const @ByRef b3Vector3 inertiaInvA, + @Const @ByRef b3Vector3 inertiaInvB); + + //constraint on one rigidbody + public b3JacobianEntry( + @Const @ByRef b3Matrix3x3 world2A, + @Const @ByRef b3Vector3 rel_pos1, @Const @ByRef b3Vector3 rel_pos2, + @Const @ByRef b3Vector3 jointAxis, + @Const @ByRef b3Vector3 inertiaInvA, + @Cast("const b3Scalar") float massInvA) { super((Pointer)null); allocate(world2A, rel_pos1, rel_pos2, jointAxis, inertiaInvA, massInvA); } + private native void allocate( + @Const @ByRef b3Matrix3x3 world2A, + @Const @ByRef b3Vector3 rel_pos1, @Const @ByRef b3Vector3 rel_pos2, + @Const @ByRef b3Vector3 jointAxis, + @Const @ByRef b3Vector3 inertiaInvA, + @Cast("const b3Scalar") float massInvA); + + public native @Cast("b3Scalar") float getDiagonal(); + + // for two constraints on the same rigidbody (for example vehicle friction) + public native @Cast("b3Scalar") float getNonDiagonal(@Const @ByRef b3JacobianEntry jacB, @Cast("const b3Scalar") float massInvA); + + // for two constraints on sharing two same rigidbodies (for example two contact points between two rigidbodies) + public native @Cast("b3Scalar") float getNonDiagonal(@Const @ByRef b3JacobianEntry jacB, @Cast("const b3Scalar") float massInvA, @Cast("const b3Scalar") float massInvB); + + public native @Cast("b3Scalar") float getRelativeVelocity(@Const @ByRef b3Vector3 linvelA, @Const @ByRef b3Vector3 angvelA, @Const @ByRef b3Vector3 linvelB, @Const @ByRef b3Vector3 angvelB); + //private: + + public native @ByRef b3Vector3 m_linearJointAxis(); public native b3JacobianEntry m_linearJointAxis(b3Vector3 setter); + public native @ByRef b3Vector3 m_aJ(); public native b3JacobianEntry m_aJ(b3Vector3 setter); + public native @ByRef b3Vector3 m_bJ(); public native b3JacobianEntry m_bJ(b3Vector3 setter); + public native @ByRef b3Vector3 m_0MinvJt(); public native b3JacobianEntry m_0MinvJt(b3Vector3 setter); + public native @ByRef b3Vector3 m_1MinvJt(); public native b3JacobianEntry m_1MinvJt(b3Vector3 setter); + //Optimization: can be stored in the w/last component of one of the vectors + public native @Cast("b3Scalar") float m_Adiag(); public native b3JacobianEntry m_Adiag(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3JointFeedback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3JointFeedback.java new file mode 100644 index 00000000000..5139d6d4012 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3JointFeedback.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +// #endif + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3JointFeedback extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3JointFeedback() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3JointFeedback(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3JointFeedback(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3JointFeedback position(long position) { + return (b3JointFeedback)super.position(position); + } + @Override public b3JointFeedback getPointer(long i) { + return new b3JointFeedback((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_appliedForceBodyA(); public native b3JointFeedback m_appliedForceBodyA(b3Vector3 setter); + public native @ByRef b3Vector3 m_appliedTorqueBodyA(); public native b3JointFeedback m_appliedTorqueBodyA(b3Vector3 setter); + public native @ByRef b3Vector3 m_appliedForceBodyB(); public native b3JointFeedback m_appliedForceBodyB(b3Vector3 setter); + public native @ByRef b3Vector3 m_appliedTorqueBodyB(); public native b3JointFeedback m_appliedTorqueBodyB(b3Vector3 setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3PgsJacobiSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3PgsJacobiSolver.java new file mode 100644 index 00000000000..00407262abd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3PgsJacobiSolver.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3PgsJacobiSolver extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3PgsJacobiSolver(Pointer p) { super(p); } + + + public b3PgsJacobiSolver(@Cast("bool") boolean usePgs) { super((Pointer)null); allocate(usePgs); } + private native void allocate(@Cast("bool") boolean usePgs); + + // void solveContacts(int numBodies, b3RigidBodyData* bodies, b3InertiaData* inertias, int numContacts, b3Contact4* contacts); + public native void solveContacts(int numBodies, b3RigidBodyData bodies, b3InertiaData inertias, int numContacts, b3Contact4 contacts, int numConstraints, @Cast("b3TypedConstraint**") PointerPointer constraints); + public native void solveContacts(int numBodies, b3RigidBodyData bodies, b3InertiaData inertias, int numContacts, b3Contact4 contacts, int numConstraints, @ByPtrPtr b3TypedConstraint constraints); + + public native @Cast("b3Scalar") float solveGroup(b3RigidBodyData bodies, b3InertiaData inertias, int numBodies, b3Contact4 manifoldPtr, int numManifolds, @Cast("b3TypedConstraint**") PointerPointer constraints, int numConstraints, @Const @ByRef b3ContactSolverInfo infoGlobal); + public native @Cast("b3Scalar") float solveGroup(b3RigidBodyData bodies, b3InertiaData inertias, int numBodies, b3Contact4 manifoldPtr, int numManifolds, @ByPtrPtr b3TypedConstraint constraints, int numConstraints, @Const @ByRef b3ContactSolverInfo infoGlobal); + + /**clear internal cached data and reset random seed */ + public native void reset(); + + public native @Cast("unsigned long") long b3Rand2(); + + public native int b3RandInt2(int n); + + public native void setRandSeed(@Cast("unsigned long") long seed); + public native @Cast("unsigned long") long getRandSeed(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraint.java new file mode 100644 index 00000000000..8106cdaae2b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraint.java @@ -0,0 +1,63 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +/** point to point constraint between two rigidbodies each with a pivotpoint that descibes the 'ballsocket' location in local space */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3Point2PointConstraint extends b3TypedConstraint { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Point2PointConstraint(Pointer p) { super(p); } + + + public native @ByRef b3ConstraintSetting m_setting(); public native b3Point2PointConstraint m_setting(b3ConstraintSetting setter); + + public b3Point2PointConstraint(int rbA, int rbB, @Const @ByRef b3Vector3 pivotInA, @Const @ByRef b3Vector3 pivotInB) { super((Pointer)null); allocate(rbA, rbB, pivotInA, pivotInB); } + private native void allocate(int rbA, int rbB, @Const @ByRef b3Vector3 pivotInA, @Const @ByRef b3Vector3 pivotInB); + + //b3Point2PointConstraint(int rbA,const b3Vector3& pivotInA); + + public native void getInfo1(b3ConstraintInfo1 info, @Const b3RigidBodyData bodies); + + public native void getInfo1NonVirtual(b3ConstraintInfo1 info, @Const b3RigidBodyData bodies); + + public native void getInfo2(b3ConstraintInfo2 info, @Const b3RigidBodyData bodies); + + public native void getInfo2NonVirtual(b3ConstraintInfo2 info, @Const @ByRef b3Transform body0_trans, @Const @ByRef b3Transform body1_trans); + + public native void updateRHS(@Cast("b3Scalar") float timeStep); + + public native void setPivotA(@Const @ByRef b3Vector3 pivotA); + + public native void setPivotB(@Const @ByRef b3Vector3 pivotB); + + public native @Const @ByRef b3Vector3 getPivotInA(); + + public native @Const @ByRef b3Vector3 getPivotInB(); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("b3Scalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("b3Scalar") float value); + /**return the local value of parameter */ + public native @Cast("b3Scalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("b3Scalar") float getParam(int num); + + // virtual int calculateSerializeBufferSize() const; + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + // virtual const char* serialize(void* dataBuffer, b3Serializer* serializer) const; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraintDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraintDoubleData.java new file mode 100644 index 00000000000..a6d1ecca226 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraintDoubleData.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3Point2PointConstraintDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Point2PointConstraintDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Point2PointConstraintDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Point2PointConstraintDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Point2PointConstraintDoubleData position(long position) { + return (b3Point2PointConstraintDoubleData)super.position(position); + } + @Override public b3Point2PointConstraintDoubleData getPointer(long i) { + return new b3Point2PointConstraintDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3TypedConstraintData m_typeConstraintData(); public native b3Point2PointConstraintDoubleData m_typeConstraintData(b3TypedConstraintData setter); + public native @ByRef b3Vector3DoubleData m_pivotInA(); public native b3Point2PointConstraintDoubleData m_pivotInA(b3Vector3DoubleData setter); + public native @ByRef b3Vector3DoubleData m_pivotInB(); public native b3Point2PointConstraintDoubleData m_pivotInB(b3Vector3DoubleData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraintFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraintFloatData.java new file mode 100644 index 00000000000..352db439847 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Point2PointConstraintFloatData.java @@ -0,0 +1,40 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3Point2PointConstraintFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3Point2PointConstraintFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Point2PointConstraintFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Point2PointConstraintFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3Point2PointConstraintFloatData position(long position) { + return (b3Point2PointConstraintFloatData)super.position(position); + } + @Override public b3Point2PointConstraintFloatData getPointer(long i) { + return new b3Point2PointConstraintFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3TypedConstraintData m_typeConstraintData(); public native b3Point2PointConstraintFloatData m_typeConstraintData(b3TypedConstraintData setter); + public native @ByRef b3Vector3FloatData m_pivotInA(); public native b3Point2PointConstraintFloatData m_pivotInA(b3Vector3FloatData setter); + public native @ByRef b3Vector3FloatData m_pivotInB(); public native b3Point2PointConstraintFloatData m_pivotInB(b3Vector3FloatData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RigidBody.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RigidBody.java new file mode 100644 index 00000000000..af862a38c5c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RigidBody.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3RigidBody extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3RigidBody() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RigidBody(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RotationalLimitMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RotationalLimitMotor.java new file mode 100644 index 00000000000..1aeea4490ee --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RotationalLimitMotor.java @@ -0,0 +1,90 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +/** Rotation Limit structure for generic joints */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3RotationalLimitMotor extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RotationalLimitMotor(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3RotationalLimitMotor(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3RotationalLimitMotor position(long position) { + return (b3RotationalLimitMotor)super.position(position); + } + @Override public b3RotationalLimitMotor getPointer(long i) { + return new b3RotationalLimitMotor((Pointer)this).offsetAddress(i); + } + + /** limit_parameters + * \{ */ + /** joint limit */ + public native @Cast("b3Scalar") float m_loLimit(); public native b3RotationalLimitMotor m_loLimit(float setter); + /** joint limit */ + public native @Cast("b3Scalar") float m_hiLimit(); public native b3RotationalLimitMotor m_hiLimit(float setter); + /** target motor velocity */ + public native @Cast("b3Scalar") float m_targetVelocity(); public native b3RotationalLimitMotor m_targetVelocity(float setter); + /** max force on motor */ + public native @Cast("b3Scalar") float m_maxMotorForce(); public native b3RotationalLimitMotor m_maxMotorForce(float setter); + /** max force on limit */ + public native @Cast("b3Scalar") float m_maxLimitForce(); public native b3RotationalLimitMotor m_maxLimitForce(float setter); + /** Damping. */ + public native @Cast("b3Scalar") float m_damping(); public native b3RotationalLimitMotor m_damping(float setter); + public native @Cast("b3Scalar") float m_limitSoftness(); public native b3RotationalLimitMotor m_limitSoftness(float setter); /** Relaxation factor */ + /** Constraint force mixing factor */ + public native @Cast("b3Scalar") float m_normalCFM(); public native b3RotationalLimitMotor m_normalCFM(float setter); + /** Error tolerance factor when joint is at limit */ + public native @Cast("b3Scalar") float m_stopERP(); public native b3RotationalLimitMotor m_stopERP(float setter); + /** Constraint force mixing factor when joint is at limit */ + public native @Cast("b3Scalar") float m_stopCFM(); public native b3RotationalLimitMotor m_stopCFM(float setter); + /** restitution factor */ + public native @Cast("b3Scalar") float m_bounce(); public native b3RotationalLimitMotor m_bounce(float setter); + public native @Cast("bool") boolean m_enableMotor(); public native b3RotationalLimitMotor m_enableMotor(boolean setter); + + /**\} +

+ * temp_variables + * \{ */ + public native @Cast("b3Scalar") float m_currentLimitError(); public native b3RotationalLimitMotor m_currentLimitError(float setter); /** How much is violated this limit */ + public native @Cast("b3Scalar") float m_currentPosition(); public native b3RotationalLimitMotor m_currentPosition(float setter); /** current value of angle */ + /** 0=free, 1=at lo limit, 2=at hi limit */ + public native int m_currentLimit(); public native b3RotationalLimitMotor m_currentLimit(int setter); + public native @Cast("b3Scalar") float m_accumulatedImpulse(); public native b3RotationalLimitMotor m_accumulatedImpulse(float setter); + /**\} */ + + public b3RotationalLimitMotor() { super((Pointer)null); allocate(); } + private native void allocate(); + + public b3RotationalLimitMotor(@Const @ByRef b3RotationalLimitMotor limot) { super((Pointer)null); allocate(limot); } + private native void allocate(@Const @ByRef b3RotationalLimitMotor limot); + + /** Is limited */ + public native @Cast("bool") boolean isLimited(); + + /** Need apply correction */ + public native @Cast("bool") boolean needApplyTorques(); + + /** calculates error + /** + calculates m_currentLimit and m_currentLimitError. + */ + public native int testLimitValue(@Cast("b3Scalar") float test_value); + + /** apply the correction impulses for two bodies */ + public native @Cast("b3Scalar") float solveAngularLimits(@Cast("b3Scalar") float timeStep, @ByRef b3Vector3 axis, @Cast("b3Scalar") float jacDiagABInv, b3RigidBodyData body0, b3RigidBodyData body1); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Serializer.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Serializer.java new file mode 100644 index 00000000000..0d6db275d5b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3Serializer.java @@ -0,0 +1,24 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3Serializer extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3Serializer() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Serializer(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3SolverBody.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3SolverBody.java new file mode 100644 index 00000000000..826a68e6bdd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3SolverBody.java @@ -0,0 +1,102 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +// #endif + +/**The b3SolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3SolverBody extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3SolverBody() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3SolverBody(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SolverBody(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3SolverBody position(long position) { + return (b3SolverBody)super.position(position); + } + @Override public b3SolverBody getPointer(long i) { + return new b3SolverBody((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Transform m_worldTransform(); public native b3SolverBody m_worldTransform(b3Transform setter); + public native @ByRef b3Vector3 m_deltaLinearVelocity(); public native b3SolverBody m_deltaLinearVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_deltaAngularVelocity(); public native b3SolverBody m_deltaAngularVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_angularFactor(); public native b3SolverBody m_angularFactor(b3Vector3 setter); + public native @ByRef b3Vector3 m_linearFactor(); public native b3SolverBody m_linearFactor(b3Vector3 setter); + public native @ByRef b3Vector3 m_invMass(); public native b3SolverBody m_invMass(b3Vector3 setter); + public native @ByRef b3Vector3 m_pushVelocity(); public native b3SolverBody m_pushVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_turnVelocity(); public native b3SolverBody m_turnVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_linearVelocity(); public native b3SolverBody m_linearVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_angularVelocity(); public native b3SolverBody m_angularVelocity(b3Vector3 setter); + public native Pointer m_originalBody(); public native b3SolverBody m_originalBody(Pointer setter); + public native int m_originalBodyIndex(); public native b3SolverBody m_originalBodyIndex(int setter); + + public native int padding(int i); public native b3SolverBody padding(int i, int setter); + @MemberGetter public native IntPointer padding(); + + public native void setWorldTransform(@Const @ByRef b3Transform worldTransform); + + public native @Const @ByRef b3Transform getWorldTransform(); + + public native void getVelocityInLocalPointObsolete(@Const @ByRef b3Vector3 rel_pos, @ByRef b3Vector3 velocity); + + public native void getAngularVelocity(@ByRef b3Vector3 angVel); + + //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position + public native void applyImpulse(@Const @ByRef b3Vector3 linearComponent, @Const @ByRef b3Vector3 angularComponent, @Cast("const b3Scalar") float impulseMagnitude); + + public native void internalApplyPushImpulse(@Const @ByRef b3Vector3 linearComponent, @Const @ByRef b3Vector3 angularComponent, @Cast("b3Scalar") float impulseMagnitude); + + public native @Const @ByRef b3Vector3 getDeltaLinearVelocity(); + + public native @Const @ByRef b3Vector3 getDeltaAngularVelocity(); + + public native @Const @ByRef b3Vector3 getPushVelocity(); + + public native @Const @ByRef b3Vector3 getTurnVelocity(); + + //////////////////////////////////////////////// + /**some internal methods, don't use them */ + + public native @ByRef b3Vector3 internalGetDeltaLinearVelocity(); + + public native @ByRef b3Vector3 internalGetDeltaAngularVelocity(); + + public native @Const @ByRef b3Vector3 internalGetAngularFactor(); + + public native @Const @ByRef b3Vector3 internalGetInvMass(); + + public native void internalSetInvMass(@Const @ByRef b3Vector3 invMass); + + public native @ByRef b3Vector3 internalGetPushVelocity(); + + public native @ByRef b3Vector3 internalGetTurnVelocity(); + + public native void internalGetVelocityInLocalPointObsolete(@Const @ByRef b3Vector3 rel_pos, @ByRef b3Vector3 velocity); + + public native void internalGetAngularVelocity(@ByRef b3Vector3 angVel); + + //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position + public native void internalApplyImpulse(@Const @ByRef b3Vector3 linearComponent, @Const @ByRef b3Vector3 angularComponent, @Cast("const b3Scalar") float impulseMagnitude); + + public native void writebackVelocity(); + + public native void writebackVelocityAndTransform(@Cast("b3Scalar") float timeStep, @Cast("b3Scalar") float splitImpulseTurnErp); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3SolverConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3SolverConstraint.java new file mode 100644 index 00000000000..003d047194b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3SolverConstraint.java @@ -0,0 +1,71 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +/**1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3SolverConstraint extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3SolverConstraint() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3SolverConstraint(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SolverConstraint(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3SolverConstraint position(long position) { + return (b3SolverConstraint)super.position(position); + } + @Override public b3SolverConstraint getPointer(long i) { + return new b3SolverConstraint((Pointer)this).offsetAddress(i); + } + + + public native @ByRef b3Vector3 m_relpos1CrossNormal(); public native b3SolverConstraint m_relpos1CrossNormal(b3Vector3 setter); + public native @ByRef b3Vector3 m_contactNormal(); public native b3SolverConstraint m_contactNormal(b3Vector3 setter); + + public native @ByRef b3Vector3 m_relpos2CrossNormal(); public native b3SolverConstraint m_relpos2CrossNormal(b3Vector3 setter); + //b3Vector3 m_contactNormal2;//usually m_contactNormal2 == -m_contactNormal + + public native @ByRef b3Vector3 m_angularComponentA(); public native b3SolverConstraint m_angularComponentA(b3Vector3 setter); + public native @ByRef b3Vector3 m_angularComponentB(); public native b3SolverConstraint m_angularComponentB(b3Vector3 setter); + + public native @Cast("b3Scalar") float m_appliedPushImpulse(); public native b3SolverConstraint m_appliedPushImpulse(float setter); + public native @Cast("b3Scalar") float m_appliedImpulse(); public native b3SolverConstraint m_appliedImpulse(float setter); + public native int m_padding1(); public native b3SolverConstraint m_padding1(int setter); + public native int m_padding2(); public native b3SolverConstraint m_padding2(int setter); + public native @Cast("b3Scalar") float m_friction(); public native b3SolverConstraint m_friction(float setter); + public native @Cast("b3Scalar") float m_jacDiagABInv(); public native b3SolverConstraint m_jacDiagABInv(float setter); + public native @Cast("b3Scalar") float m_rhs(); public native b3SolverConstraint m_rhs(float setter); + public native @Cast("b3Scalar") float m_cfm(); public native b3SolverConstraint m_cfm(float setter); + + public native @Cast("b3Scalar") float m_lowerLimit(); public native b3SolverConstraint m_lowerLimit(float setter); + public native @Cast("b3Scalar") float m_upperLimit(); public native b3SolverConstraint m_upperLimit(float setter); + public native @Cast("b3Scalar") float m_rhsPenetration(); public native b3SolverConstraint m_rhsPenetration(float setter); + public native Pointer m_originalContactPoint(); public native b3SolverConstraint m_originalContactPoint(Pointer setter); + public native @Cast("b3Scalar") float m_unusedPadding4(); public native b3SolverConstraint m_unusedPadding4(float setter); + + public native int m_overrideNumSolverIterations(); public native b3SolverConstraint m_overrideNumSolverIterations(int setter); + public native int m_frictionIndex(); public native b3SolverConstraint m_frictionIndex(int setter); + public native int m_solverBodyIdA(); public native b3SolverConstraint m_solverBodyIdA(int setter); + public native int m_solverBodyIdB(); public native b3SolverConstraint m_solverBodyIdB(int setter); + + /** enum b3SolverConstraint::b3SolverConstraintType */ + public static final int + B3_SOLVER_CONTACT_1D = 0, + B3_SOLVER_FRICTION_1D = 1; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TranslationalLimitMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TranslationalLimitMotor.java new file mode 100644 index 00000000000..4448b652c71 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TranslationalLimitMotor.java @@ -0,0 +1,89 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3TranslationalLimitMotor extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TranslationalLimitMotor(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3TranslationalLimitMotor(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3TranslationalLimitMotor position(long position) { + return (b3TranslationalLimitMotor)super.position(position); + } + @Override public b3TranslationalLimitMotor getPointer(long i) { + return new b3TranslationalLimitMotor((Pointer)this).offsetAddress(i); + } + + /** the constraint lower limits */ + public native @ByRef b3Vector3 m_lowerLimit(); public native b3TranslationalLimitMotor m_lowerLimit(b3Vector3 setter); + /** the constraint upper limits */ + public native @ByRef b3Vector3 m_upperLimit(); public native b3TranslationalLimitMotor m_upperLimit(b3Vector3 setter); + public native @ByRef b3Vector3 m_accumulatedImpulse(); public native b3TranslationalLimitMotor m_accumulatedImpulse(b3Vector3 setter); + /** Linear_Limit_parameters + * \{ */ + /** Constraint force mixing factor */ + public native @ByRef b3Vector3 m_normalCFM(); public native b3TranslationalLimitMotor m_normalCFM(b3Vector3 setter); + /** Error tolerance factor when joint is at limit */ + public native @ByRef b3Vector3 m_stopERP(); public native b3TranslationalLimitMotor m_stopERP(b3Vector3 setter); + /** Constraint force mixing factor when joint is at limit */ + public native @ByRef b3Vector3 m_stopCFM(); public native b3TranslationalLimitMotor m_stopCFM(b3Vector3 setter); + /** target motor velocity */ + public native @ByRef b3Vector3 m_targetVelocity(); public native b3TranslationalLimitMotor m_targetVelocity(b3Vector3 setter); + /** max force on motor */ + public native @ByRef b3Vector3 m_maxMotorForce(); public native b3TranslationalLimitMotor m_maxMotorForce(b3Vector3 setter); + public native @ByRef b3Vector3 m_currentLimitError(); public native b3TranslationalLimitMotor m_currentLimitError(b3Vector3 setter); /** How much is violated this limit */ + public native @ByRef b3Vector3 m_currentLinearDiff(); public native b3TranslationalLimitMotor m_currentLinearDiff(b3Vector3 setter); /** Current relative offset of constraint frames */ + /** Softness for linear limit */ + public native @Cast("b3Scalar") float m_limitSoftness(); public native b3TranslationalLimitMotor m_limitSoftness(float setter); + /** Damping for linear limit */ + public native @Cast("b3Scalar") float m_damping(); public native b3TranslationalLimitMotor m_damping(float setter); + public native @Cast("b3Scalar") float m_restitution(); public native b3TranslationalLimitMotor m_restitution(float setter); /** Bounce parameter for linear limit + * \} */ + public native @Cast("bool") boolean m_enableMotor(int i); public native b3TranslationalLimitMotor m_enableMotor(int i, boolean setter); + @MemberGetter public native @Cast("bool*") BoolPointer m_enableMotor(); + /** 0=free, 1=at lower limit, 2=at upper limit */ + public native int m_currentLimit(int i); public native b3TranslationalLimitMotor m_currentLimit(int i, int setter); + @MemberGetter public native IntPointer m_currentLimit(); + + public b3TranslationalLimitMotor() { super((Pointer)null); allocate(); } + private native void allocate(); + + public b3TranslationalLimitMotor(@Const @ByRef b3TranslationalLimitMotor other) { super((Pointer)null); allocate(other); } + private native void allocate(@Const @ByRef b3TranslationalLimitMotor other); + + /** Test limit + /** + - free means upper < lower, + - locked means upper == lower + - limited means upper > lower + - limitIndex: first 3 are linear, next 3 are angular + */ + public native @Cast("bool") boolean isLimited(int limitIndex); + public native @Cast("bool") boolean needApplyForce(int limitIndex); + public native int testLimitValue(int limitIndex, @Cast("b3Scalar") float test_value); + + public native @Cast("b3Scalar") float solveLinearAxis( + @Cast("b3Scalar") float timeStep, + @Cast("b3Scalar") float jacDiagABInv, + @ByRef b3RigidBodyData body1, @Const @ByRef b3Vector3 pointInA, + @ByRef b3RigidBodyData body2, @Const @ByRef b3Vector3 pointInB, + int limit_index, + @Const @ByRef b3Vector3 axis_normal_on_a, + @Const @ByRef b3Vector3 anchorPos); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraint.java new file mode 100644 index 00000000000..e1081f86f24 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraint.java @@ -0,0 +1,183 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +/**TypedConstraint is the baseclass for Bullet constraints and vehicles */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3TypedConstraint extends b3TypedObject { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TypedConstraint(Pointer p) { super(p); } + + + public static class b3ConstraintInfo1 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ConstraintInfo1() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConstraintInfo1(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConstraintInfo1(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ConstraintInfo1 position(long position) { + return (b3ConstraintInfo1)super.position(position); + } + @Override public b3ConstraintInfo1 getPointer(long i) { + return new b3ConstraintInfo1((Pointer)this).offsetAddress(i); + } + + public native int m_numConstraintRows(); public native b3ConstraintInfo1 m_numConstraintRows(int setter); + public native int nub(); public native b3ConstraintInfo1 nub(int setter); + } + + public static class b3ConstraintInfo2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ConstraintInfo2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConstraintInfo2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConstraintInfo2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ConstraintInfo2 position(long position) { + return (b3ConstraintInfo2)super.position(position); + } + @Override public b3ConstraintInfo2 getPointer(long i) { + return new b3ConstraintInfo2((Pointer)this).offsetAddress(i); + } + + // integrator parameters: frames per second (1/stepsize), default error + // reduction parameter (0..1). + public native @Cast("b3Scalar") float fps(); public native b3ConstraintInfo2 fps(float setter); + public native @Cast("b3Scalar") float erp(); public native b3ConstraintInfo2 erp(float setter); + + // for the first and second body, pointers to two (linear and angular) + // n*3 jacobian sub matrices, stored by rows. these matrices will have + // been initialized to 0 on entry. if the second body is zero then the + // J2xx pointers may be 0. + public native @Cast("b3Scalar*") FloatPointer m_J1linearAxis(); public native b3ConstraintInfo2 m_J1linearAxis(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer m_J1angularAxis(); public native b3ConstraintInfo2 m_J1angularAxis(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer m_J2linearAxis(); public native b3ConstraintInfo2 m_J2linearAxis(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer m_J2angularAxis(); public native b3ConstraintInfo2 m_J2angularAxis(FloatPointer setter); + + // elements to jump from one row to the next in J's + public native int rowskip(); public native b3ConstraintInfo2 rowskip(int setter); + + // right hand sides of the equation J*v = c + cfm * lambda. cfm is the + // "constraint force mixing" vector. c is set to zero on entry, cfm is + // set to a constant value (typically very small or zero) value on entry. + public native @Cast("b3Scalar*") FloatPointer m_constraintError(); public native b3ConstraintInfo2 m_constraintError(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer cfm(); public native b3ConstraintInfo2 cfm(FloatPointer setter); + + // lo and hi limits for variables (set to -/+ infinity on entry). + public native @Cast("b3Scalar*") FloatPointer m_lowerLimit(); public native b3ConstraintInfo2 m_lowerLimit(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer m_upperLimit(); public native b3ConstraintInfo2 m_upperLimit(FloatPointer setter); + + // findex vector for variables. see the LCP solver interface for a + // description of what this does. this is set to -1 on entry. + // note that the returned indexes are relative to the first index of + // the constraint. + public native IntPointer findex(); public native b3ConstraintInfo2 findex(IntPointer setter); + // number of solver iterations + public native int m_numIterations(); public native b3ConstraintInfo2 m_numIterations(int setter); + + //damping of the velocity + public native @Cast("b3Scalar") float m_damping(); public native b3ConstraintInfo2 m_damping(float setter); + } + + public native int getOverrideNumSolverIterations(); + + /**override the number of constraint solver iterations used to solve this constraint + * -1 will use the default number of iterations, as specified in SolverInfo.m_numIterations */ + public native void setOverrideNumSolverIterations(int overideNumIterations); + + /**internal method used by the constraint solver, don't use them directly */ + public native void setupSolverConstraint(@Cast("b3ConstraintArray*") @ByRef b3IntArray ca, int solverBodyA, int solverBodyB, @Cast("b3Scalar") float timeStep); + + /**internal method used by the constraint solver, don't use them directly */ + public native void getInfo1(b3ConstraintInfo1 info, @Const b3RigidBodyData bodies); + + /**internal method used by the constraint solver, don't use them directly */ + public native void getInfo2(b3ConstraintInfo2 info, @Const b3RigidBodyData bodies); + + /**internal method used by the constraint solver, don't use them directly */ + public native void internalSetAppliedImpulse(@Cast("b3Scalar") float appliedImpulse); + /**internal method used by the constraint solver, don't use them directly */ + public native @Cast("b3Scalar") float internalGetAppliedImpulse(); + + public native @Cast("b3Scalar") float getBreakingImpulseThreshold(); + + public native void setBreakingImpulseThreshold(@Cast("b3Scalar") float threshold); + + public native @Cast("bool") boolean isEnabled(); + + public native void setEnabled(@Cast("bool") boolean enabled); + + /**internal method used by the constraint solver, don't use them directly */ + public native void solveConstraintObsolete(@ByRef b3SolverBody arg0, @ByRef b3SolverBody arg1, @Cast("b3Scalar") float arg2); + + public native int getRigidBodyA(); + public native int getRigidBodyB(); + + public native int getUserConstraintType(); + + public native void setUserConstraintType(int userConstraintType); + + public native void setUserConstraintId(int uid); + + public native int getUserConstraintId(); + + public native void setUserConstraintPtr(Pointer ptr); + + public native Pointer getUserConstraintPtr(); + + public native void setJointFeedback(b3JointFeedback jointFeedback); + + public native b3JointFeedback getJointFeedback(); + + public native int getUid(); + + public native @Cast("bool") boolean needsFeedback(); + + /**enableFeedback will allow to read the applied linear and angular impulse + * use getAppliedImpulse, getAppliedLinearImpulse and getAppliedAngularImpulse to read feedback information */ + public native void enableFeedback(@Cast("bool") boolean needsFeedback); + + /**getAppliedImpulse is an estimated total applied impulse. + * This feedback could be used to determine breaking constraints or playing sounds. */ + public native @Cast("b3Scalar") float getAppliedImpulse(); + + public native @Cast("b3TypedConstraintType") int getConstraintType(); + + public native void setDbgDrawSize(@Cast("b3Scalar") float dbgDrawSize); + public native @Cast("b3Scalar") float getDbgDrawSize(); + + /**override the default global value of a parameter (such as ERP or CFM), optionally provide the axis (0..5). + * If no axis is provided, it uses the default axis for this constraint. */ + public native void setParam(int num, @Cast("b3Scalar") float value, int axis/*=-1*/); + public native void setParam(int num, @Cast("b3Scalar") float value); + + /**return the local value of parameter */ + public native @Cast("b3Scalar") float getParam(int num, int axis/*=-1*/); + public native @Cast("b3Scalar") float getParam(int num); + + // virtual int calculateSerializeBufferSize() const; + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + //virtual const char* serialize(void* dataBuffer, b3Serializer* serializer) const; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraintData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraintData.java new file mode 100644 index 00000000000..f0c1fc76cdb --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraintData.java @@ -0,0 +1,56 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + + +// clang-format off +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3TypedConstraintData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3TypedConstraintData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3TypedConstraintData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TypedConstraintData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3TypedConstraintData position(long position) { + return (b3TypedConstraintData)super.position(position); + } + @Override public b3TypedConstraintData getPointer(long i) { + return new b3TypedConstraintData((Pointer)this).offsetAddress(i); + } + + public native int m_bodyA(); public native b3TypedConstraintData m_bodyA(int setter); + public native int m_bodyB(); public native b3TypedConstraintData m_bodyB(int setter); + public native @Cast("char*") BytePointer m_name(); public native b3TypedConstraintData m_name(BytePointer setter); + + public native int m_objectType(); public native b3TypedConstraintData m_objectType(int setter); + public native int m_userConstraintType(); public native b3TypedConstraintData m_userConstraintType(int setter); + public native int m_userConstraintId(); public native b3TypedConstraintData m_userConstraintId(int setter); + public native int m_needsFeedback(); public native b3TypedConstraintData m_needsFeedback(int setter); + + public native float m_appliedImpulse(); public native b3TypedConstraintData m_appliedImpulse(float setter); + public native float m_dbgDrawSize(); public native b3TypedConstraintData m_dbgDrawSize(float setter); + + public native int m_disableCollisionsBetweenLinkedBodies(); public native b3TypedConstraintData m_disableCollisionsBetweenLinkedBodies(int setter); + public native int m_overrideNumSolverIterations(); public native b3TypedConstraintData m_overrideNumSolverIterations(int setter); + + public native float m_breakingImpulseThreshold(); public native b3TypedConstraintData m_breakingImpulseThreshold(float setter); + public native int m_isEnabled(); public native b3TypedConstraintData m_isEnabled(int setter); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java index e2246476db2..012d9ac4fa1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java @@ -85,6 +85,12 @@ public class Bullet3Collision extends org.bytedeco.bullet.presets.Bullet3Collisi // Targeting ../Bullet3Collision/b3MyFaceArray.java +// Targeting ../Bullet3Collision/b3RayHitArray.java + + +// Targeting ../Bullet3Collision/b3RayInfoArray.java + + // Targeting ../Bullet3Collision/b3RigidBodyDataArray.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java new file mode 100644 index 00000000000..e4335f6af6d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java @@ -0,0 +1,498 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.global; + +import org.bytedeco.bullet.Bullet3Dynamics.*; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +public class Bullet3Dynamics extends org.bytedeco.bullet.presets.Bullet3Dynamics { + static { Loader.load(); } + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_CONTACT_SOLVER_INFO +// #define B3_CONTACT_SOLVER_INFO + +// #include "Bullet3Common/b3Scalar.h" + +/** enum b3SolverMode */ +public static final int + B3_SOLVER_RANDMIZE_ORDER = 1, + B3_SOLVER_FRICTION_SEPARATE = 2, + B3_SOLVER_USE_WARMSTARTING = 4, + B3_SOLVER_USE_2_FRICTION_DIRECTIONS = 16, + B3_SOLVER_ENABLE_FRICTION_DIRECTION_CACHING = 32, + B3_SOLVER_DISABLE_VELOCITY_DEPENDENT_FRICTION_DIRECTION = 64, + B3_SOLVER_CACHE_FRIENDLY = 128, + B3_SOLVER_SIMD = 256, + B3_SOLVER_INTERLEAVE_CONTACT_AND_FRICTION_CONSTRAINTS = 512, + B3_SOLVER_ALLOW_ZERO_LENGTH_FRICTION_DIRECTIONS = 1024; +// Targeting ../Bullet3Dynamics/b3ContactSolverInfoData.java + + +// Targeting ../Bullet3Dynamics/b3ContactSolverInfo.java + + +// Targeting ../Bullet3Dynamics/b3ContactSolverInfoDoubleData.java + + +// Targeting ../Bullet3Dynamics/b3ContactSolverInfoFloatData.java + + + +// #endif //B3_CONTACT_SOLVER_INFO + + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3SolverBody.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_SOLVER_BODY_H +// #define B3_SOLVER_BODY_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Common/b3Matrix3x3.h" + +// #include "Bullet3Common/b3AlignedAllocator.h" +// #include "Bullet3Common/b3TransformUtil.h" + +/**Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision */ +// #ifdef B3_USE_SSE +// #endif // + +// #ifdef USE_SIMD + +// #else +// #define b3SimdScalar b3Scalar +// Targeting ../Bullet3Dynamics/b3SolverBody.java + + + +// #endif //B3_SOLVER_BODY_H + + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3SolverConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_SOLVER_CONSTRAINT_H +// #define B3_SOLVER_CONSTRAINT_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Common/b3Matrix3x3.h" +//#include "b3JacobianEntry.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" + +//#define NO_FRICTION_TANGENTIALS 1 +// #include "b3SolverBody.h" +// Targeting ../Bullet3Dynamics/b3SolverConstraint.java + + + +// #endif //B3_SOLVER_CONSTRAINT_H + + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2010 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_TYPED_CONSTRAINT_H +// #define B3_TYPED_CONSTRAINT_H + +// #include "Bullet3Common/b3Scalar.h" +// #include "b3SolverConstraint.h" +// Targeting ../Bullet3Dynamics/b3Serializer.java + + + +//Don't change any of the existing enum values, so add enum types at the end for serialization compatibility +/** enum b3TypedConstraintType */ +public static final int + B3_POINT2POINT_CONSTRAINT_TYPE = 3, + B3_HINGE_CONSTRAINT_TYPE = 4, + B3_CONETWIST_CONSTRAINT_TYPE = 5, + B3_D6_CONSTRAINT_TYPE = 6, + B3_SLIDER_CONSTRAINT_TYPE = 7, + B3_CONTACT_CONSTRAINT_TYPE = 8, + B3_D6_SPRING_CONSTRAINT_TYPE = 9, + B3_GEAR_CONSTRAINT_TYPE = 10, + B3_FIXED_CONSTRAINT_TYPE = 11, + B3_MAX_CONSTRAINT_TYPE = 12; + +/** enum b3ConstraintParams */ +public static final int + B3_CONSTRAINT_ERP = 1, + B3_CONSTRAINT_STOP_ERP = 2, + B3_CONSTRAINT_CFM = 3, + B3_CONSTRAINT_STOP_CFM = 4; + +// #if 1 +// #define b3AssertConstrParams(_par) b3Assert(_par) +// #else +// #define b3AssertConstrParams(_par) +// Targeting ../Bullet3Dynamics/b3JointFeedback.java + + +// Targeting ../Bullet3Dynamics/b3TypedConstraint.java + + + +// returns angle in range [-B3_2_PI, B3_2_PI], closest to one of the limits +// all arguments should be normalized angles (i.e. in range [-B3_PI, B3_PI]) +public static native @Cast("b3Scalar") float b3AdjustAngleToLimits(@Cast("b3Scalar") float angleInRadians, @Cast("b3Scalar") float angleLowerLimitInRadians, @Cast("b3Scalar") float angleUpperLimitInRadians); +// Targeting ../Bullet3Dynamics/b3TypedConstraintData.java + + +// Targeting ../Bullet3Dynamics/b3AngularLimit.java + + + +// #endif //B3_TYPED_CONSTRAINT_H + + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3FixedConstraint.h + + +// #ifndef B3_FIXED_CONSTRAINT_H +// #define B3_FIXED_CONSTRAINT_H + +// #include "b3TypedConstraint.h" +// Targeting ../Bullet3Dynamics/b3FixedConstraint.java + + + +// #endif //B3_FIXED_CONSTRAINT_H + + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3Generic6DofConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/** 2009 March: b3Generic6DofConstraint refactored by Roman Ponomarev +/** Added support for generic constraint solver through getInfo1/getInfo2 methods */ + +/* +2007-09-09 +b3Generic6DofConstraint Refactored by Francisco Le?n +email: projectileman@yahoo.com +http://gimpact.sf.net +*/ + +// #ifndef B3_GENERIC_6DOF_CONSTRAINT_H +// #define B3_GENERIC_6DOF_CONSTRAINT_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "b3JacobianEntry.h" +// #include "b3TypedConstraint.h" +// Targeting ../Bullet3Dynamics/b3RotationalLimitMotor.java + + +// Targeting ../Bullet3Dynamics/b3TranslationalLimitMotor.java + + + +/** enum b36DofFlags */ +public static final int + B3_6DOF_FLAGS_CFM_NORM = 1, + B3_6DOF_FLAGS_CFM_STOP = 2, + B3_6DOF_FLAGS_ERP_STOP = 4; +public static final int B3_6DOF_FLAGS_AXIS_SHIFT = 3; +// Targeting ../Bullet3Dynamics/b3Generic6DofConstraint.java + + + +// #endif //B3_GENERIC_6DOF_CONSTRAINT_H + + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3JacobianEntry.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_JACOBIAN_ENTRY_H +// #define B3_JACOBIAN_ENTRY_H + +// #include "Bullet3Common/b3Matrix3x3.h" +// Targeting ../Bullet3Dynamics/b3JacobianEntry.java + + + +// #endif //B3_JACOBIAN_ENTRY_H + + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3PgsJacobiSolver.h + +// #ifndef B3_PGS_JACOBI_SOLVER +// #define B3_PGS_JACOBI_SOLVER +// Targeting ../Bullet3Dynamics/b3ContactPoint.java + + +// Targeting ../Bullet3Dynamics/b3Dispatcher.java + + + +// #include "b3TypedConstraint.h" +// #include "b3ContactSolverInfo.h" +// #include "b3SolverBody.h" +// #include "b3SolverConstraint.h" +// Targeting ../Bullet3Dynamics/b3PgsJacobiSolver.java + + + +// #endif //B3_PGS_JACOBI_SOLVER + + +// Parsed from Bullet3Dynamics/ConstraintSolver/b3Point2PointConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_POINT2POINTCONSTRAINT_H +// #define B3_POINT2POINTCONSTRAINT_H + +// #include "Bullet3Common/b3Vector3.h" +//#include "b3JacobianEntry.h" +// #include "b3TypedConstraint.h" +// Targeting ../Bullet3Dynamics/b3RigidBody.java + + + +// #ifdef B3_USE_DOUBLE_PRECISION +// #else +// #define b3Point2PointConstraintData b3Point2PointConstraintFloatData +public static final String b3Point2PointConstraintDataName = "b3Point2PointConstraintFloatData"; +// Targeting ../Bullet3Dynamics/b3ConstraintSetting.java + + + +/** enum b3Point2PointFlags */ +public static final int + B3_P2P_FLAGS_ERP = 1, + B3_P2P_FLAGS_CFM = 2; +// Targeting ../Bullet3Dynamics/b3Point2PointConstraint.java + + +// Targeting ../Bullet3Dynamics/b3Point2PointConstraintFloatData.java + + +// Targeting ../Bullet3Dynamics/b3Point2PointConstraintDoubleData.java + + + +/* +B3_FORCE_INLINE int b3Point2PointConstraint::calculateSerializeBufferSize() const +{ + return sizeof(b3Point2PointConstraintData); + +} + + ///fills the dataBuffer and returns the struct name (and 0 on failure) +B3_FORCE_INLINE const char* b3Point2PointConstraint::serialize(void* dataBuffer, b3Serializer* serializer) const +{ + b3Point2PointConstraintData* p2pData = (b3Point2PointConstraintData*)dataBuffer; + + b3TypedConstraint::serialize(&p2pData->m_typeConstraintData,serializer); + m_pivotInA.serialize(p2pData->m_pivotInA); + m_pivotInB.serialize(p2pData->m_pivotInB); + + return b3Point2PointConstraintDataName; +} +*/ + +// #endif //B3_POINT2POINTCONSTRAINT_H + + +// Parsed from Bullet3Dynamics/shared/b3ContactConstraint4.h + +// #ifndef B3_CONTACT_CONSTRAINT5_H +// #define B3_CONTACT_CONSTRAINT5_H + +// #include "Bullet3Common/shared/b3Float4.h" +// Targeting ../Bullet3Dynamics/b3ContactConstraint4.java + + + +//inline void setFrictionCoeff(float value) { m_linear[3] = value; } +public static native float b3GetFrictionCoeff(b3ContactConstraint4 constraint); + +// #endif //B3_CONTACT_CONSTRAINT5_H + + +// Parsed from Bullet3Dynamics/shared/b3ConvertConstraint4.h + + + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h" +// #include "Bullet3Dynamics/shared/b3ContactConstraint4.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" + +public static native void b3PlaneSpace1(@Const @ByRef b3Vector3 n, b3Vector3 p, b3Vector3 q); + +public static native void setLinearAndAngular(@Const @ByRef b3Vector3 n, @Const @ByRef b3Vector3 r0, @Const @ByRef b3Vector3 r1, b3Vector3 linear, b3Vector3 angular0, b3Vector3 angular1); + +public static native float calcRelVel(@Const @ByRef b3Vector3 l0, @Const @ByRef b3Vector3 l1, @Const @ByRef b3Vector3 a0, @Const @ByRef b3Vector3 a1, @Const @ByRef b3Vector3 linVel0, + @Const @ByRef b3Vector3 angVel0, @Const @ByRef b3Vector3 linVel1, @Const @ByRef b3Vector3 angVel1); + +public static native float calcJacCoeff(@Const @ByRef b3Vector3 linear0, @Const @ByRef b3Vector3 linear1, @Const @ByRef b3Vector3 angular0, @Const @ByRef b3Vector3 angular1, + float invMass0, @Const b3Matrix3x3 invInertia0, float invMass1, @Const b3Matrix3x3 invInertia1); + +public static native void setConstraint4(@Const @ByRef b3Vector3 posA, @Const @ByRef b3Vector3 linVelA, @Const @ByRef b3Vector3 angVelA, float invMassA, @Const @ByRef b3Matrix3x3 invInertiaA, + @Const @ByRef b3Vector3 posB, @Const @ByRef b3Vector3 linVelB, @Const @ByRef b3Vector3 angVelB, float invMassB, @Const @ByRef b3Matrix3x3 invInertiaB, + b3Contact4Data src, float dt, float positionDrift, float positionConstraintCoeff, + b3ContactConstraint4 dstC); + + +// Parsed from Bullet3Dynamics/shared/b3Inertia.h + + + +// #ifndef B3_INERTIA_H +// #define B3_INERTIA_H + +// #include "Bullet3Common/shared/b3Mat3x3.h" +// Targeting ../Bullet3Dynamics/b3Inertia.java + + + +// #endif //B3_INERTIA_H + +// Parsed from Bullet3Dynamics/shared/b3IntegrateTransforms.h + + + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" + +public static native void integrateSingleTransform(b3RigidBodyData bodies, int nodeID, float timeStep, float angularDamping, @Const @ByRef b3Vector3 gravityAcceleration); + +public static native void b3IntegrateTransform(b3RigidBodyData body, float timeStep, float angularDamping, @Const @ByRef b3Vector3 gravityAcceleration); + + +// Parsed from Bullet3Dynamics/b3CpuRigidBodyPipeline.h + +/* +Copyright (c) 2013 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Erwin Coumans + +// #ifndef B3_CPU_RIGIDBODY_PIPELINE_H +// #define B3_CPU_RIGIDBODY_PIPELINE_H + +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h" +// Targeting ../Bullet3Dynamics/b3CpuRigidBodyPipeline.java + + + +// #endif //B3_CPU_RIGIDBODY_PIPELINE_H + +} From 6400dceeff375534e7e344dce2cece83447787a3 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 8 Mar 2022 17:52:43 +0800 Subject: [PATCH 67/81] Mappings for Bullet3OpenCL library --- bullet/pom.xml | 2 +- .../bullet/presets/Bullet3Collision.java | 70 ++--- .../bullet/presets/Bullet3Common.java | 23 ++ .../bullet/presets/Bullet3Dynamics.java | 2 + .../bullet/presets/Bullet3OpenCL.java | 244 ++++++++++++++++++ bullet/src/main/java9/module-info.java | 1 + 6 files changed, 286 insertions(+), 56 deletions(-) create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java diff --git a/bullet/pom.xml b/bullet/pom.xml index c737a868c60..5760bcdacf7 100644 --- a/bullet/pom.xml +++ b/bullet/pom.xml @@ -34,7 +34,7 @@ javacpp - ${basedir}/cppbuild/${javacpp.platform}/include/bullet + ${basedir}/cppbuild/${javacpp.platform}/bullet3-3.21/src diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java index 4fccbab676d..620d5f7279c 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java @@ -88,19 +88,9 @@ public void map(InfoMap infoMap) { .put(new Info("_b3MprSimplex_t").pointerTypes("b3MprSimplex_t")) .put(new Info("_b3MprSupport_t").pointerTypes("b3MprSupport_t")) .put(new Info("b3Aabb_t").pointerTypes("b3Aabb")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3AabbArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3CollidableArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3Contact4DataArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3ConvexPolyhedronDataArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3DbvtProxyArray")) .put(new Info("b3AlignedObjectArray").pointerTypes("sStkNNArray")) .put(new Info("b3AlignedObjectArray").pointerTypes("sStkNPSArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3GpuChildShapeArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3GpuFaceArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3MyFaceArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3RayHitArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3RayInfoArray")) - .put(new Info("b3AlignedObjectArray").pointerTypes("b3RigidBodyDataArray")) + .put(new Info("b3BroadphasePair").pointerTypes("b3Int4")) .put(new Info("b3BvhSubtreeInfoData_t").pointerTypes("b3BvhSubtreeInfoData")) .put(new Info("b3Collidable_t").pointerTypes("b3Collidable")) .put(new Info("b3Contact4Data_t").pointerTypes("b3Contact4Data")) @@ -116,26 +106,6 @@ public void map(InfoMap infoMap) { .put(new Info("b3BroadphaseRayCallback").purify(true)) .put(new Info( - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", "b3AlignedObjectArray::findBinarySearch", "b3AlignedObjectArray::findLinearSearch", "b3AlignedObjectArray::findLinearSearch2", @@ -144,34 +114,24 @@ public void map(InfoMap infoMap) { "b3AlignedObjectArray::findLinearSearch", "b3AlignedObjectArray::findLinearSearch2", "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", - "b3AlignedObjectArray::findBinarySearch", - "b3AlignedObjectArray::findLinearSearch", - "b3AlignedObjectArray::findLinearSearch2", - "b3AlignedObjectArray::remove", "b3CpuNarrowPhase::getInternalData", "b3DynamicBvh::extractLeaves", "b3DynamicBvh::m_rayTestStack" ).skip()) ; + + Bullet3Common.mapArrays(infoMap, + "b3Aabb", + "b3Collidable", + "b3Contact4Data", + "b3ConvexPolyhedronData", + "b3DbvtProxy", + "b3GpuChildShape", + "b3GpuFace", + "b3MyFace", + "b3RayHit", + "b3RayInfo", + "b3RigidBodyData" + ); } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java index 8110b238eb9..22cf9ae8a42 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Common.java @@ -69,6 +69,20 @@ public class Bullet3Common implements InfoMapper { static { Loader.checkVersion("org.bytedeco", "bullet"); } + public static void mapArrays(InfoMap infoMap, String... typeNames) { + for (String typeName: typeNames) { + String cppName = "b3AlignedObjectArray<" + typeName + ">"; + String javaName = typeName + "Array"; + infoMap.put(new Info(cppName).pointerTypes(javaName)); + infoMap.put(new Info( + cppName + "::findBinarySearch", + cppName + "::findLinearSearch", + cppName + "::findLinearSearch2", + cppName + "::remove" + ).skip()); + } + } + public void map(InfoMap infoMap) { infoMap .put(new Info("B3_ATTRIBUTE_ALIGNED16").cppText("#define B3_ATTRIBUTE_ALIGNED16(x) x")) @@ -121,13 +135,22 @@ public void map(InfoMap infoMap) { "__cplusplus" ).define(true)) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3UnsignedCharArray")) .put(new Info("b3AlignedObjectArray").pointerTypes("b3IntArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3UnsignedIntArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3FloatArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3Int2Array")) .put(new Info("b3AlignedObjectArray").pointerTypes("b3Int4Array")) .put(new Info("b3AlignedObjectArray").pointerTypes("b3Vector3Array")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3Int4Array")) .put(new Info("b3AlignedObjectArray.h").linePatterns("\tclass less", "\t};").skip()) .put(new Info( + "b3AlignedObjectArray::findBinarySearch", + "b3AlignedObjectArray::findLinearSearch", + "b3AlignedObjectArray::findLinearSearch2", + "b3AlignedObjectArray::remove", "b3AlignedObjectArray::findBinarySearch", "b3AlignedObjectArray::findLinearSearch", "b3AlignedObjectArray::findLinearSearch2", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java index 4724aa6bcb7..c7d62379ec4 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java @@ -39,6 +39,7 @@ value = { @Platform( include = { + "Bullet3Common/b3AlignedObjectArray.h", "Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h", "Bullet3Dynamics/ConstraintSolver/b3SolverBody.h", "Bullet3Dynamics/ConstraintSolver/b3SolverConstraint.h", @@ -70,6 +71,7 @@ public void map(InfoMap infoMap) { "b3Point2PointConstraintData" ).cppTypes().translate(false)) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3TypedConstraintArray")) .put(new Info("b3ContactConstraint4_t").pointerTypes("b3ContactConstraint4")) ; } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java new file mode 100644 index 00000000000..7694e884c02 --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java @@ -0,0 +1,244 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.Pointer; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +/** + * + * @author Andrey Krainyak + */ +@Properties( + inherit = Bullet3Dynamics.class, + value = { + @Platform( + define = { + "B3_USE_CLEW", + }, + include = { + "Bullet3Common/b3AlignedObjectArray.h", + "Bullet3OpenCL/Initialize/b3OpenCLUtils.h", + "Bullet3OpenCL/ParallelPrimitives/b3BufferInfoCL.h", + "Bullet3OpenCL/ParallelPrimitives/b3LauncherCL.h", + "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h", + "Bullet3OpenCL/ParallelPrimitives/b3FillCL.h", + "Bullet3OpenCL/ParallelPrimitives/b3PrefixScanFloat4CL.h", + "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h", + "Bullet3OpenCL/ParallelPrimitives/b3BoundSearchCL.h", + "Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h", + "Bullet3OpenCL/BroadphaseCollision/b3GpuBroadphaseInterface.h", + "Bullet3OpenCL/BroadphaseCollision/b3GpuGridBroadphase.h", + "Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvhBroadphase.h", + "Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvh.h", + "Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.h", + "Bullet3OpenCL/NarrowphaseCollision/b3BvhInfo.h", + "Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.h", + "Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.h", + "Bullet3OpenCL/NarrowphaseCollision/b3ConvexPolyhedronCL.h", + "Bullet3OpenCL/NarrowphaseCollision/b3GjkEpa.h", + "Bullet3OpenCL/NarrowphaseCollision/b3OptimizedBvh.h", + "Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.h", + "Bullet3OpenCL/NarrowphaseCollision/b3StridingMeshInterface.h", + "Bullet3OpenCL/NarrowphaseCollision/b3VectorFloat4.h", + "Bullet3OpenCL/NarrowphaseCollision/b3SupportMappings.h", + "Bullet3OpenCL/NarrowphaseCollision/b3TriangleCallback.h", + "Bullet3OpenCL/NarrowphaseCollision/b3TriangleIndexVertexArray.h", + "Bullet3OpenCL/NarrowphaseCollision/b3VoronoiSimplexSolver.h", + "Bullet3OpenCL/RigidBody/b3GpuConstraint4.h", + "Bullet3OpenCL/RigidBody/b3GpuGenericConstraint.h", + "Bullet3OpenCL/RigidBody/b3GpuJacobiContactSolver.h", + "Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h", + "Bullet3OpenCL/RigidBody/b3GpuNarrowPhaseInternalData.h", + "Bullet3OpenCL/RigidBody/b3GpuPgsConstraintSolver.h", + "Bullet3OpenCL/RigidBody/b3GpuPgsContactSolver.h", + "Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h", + "Bullet3OpenCL/Raycast/b3GpuRaycast.h", + "Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h", + "Bullet3OpenCL/RigidBody/b3GpuSolverBody.h", + "Bullet3OpenCL/RigidBody/b3GpuSolverConstraint.h", + "Bullet3OpenCL/RigidBody/b3Solver.h", + + }, + link = "Bullet3OpenCL_clew@.3.20" + ) + }, + target = "org.bytedeco.bullet.Bullet3OpenCL", + global = "org.bytedeco.bullet.global.Bullet3OpenCL" +) +public class Bullet3OpenCL implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + private static void mapOCLArrays(InfoMap infoMap, String... typeNames) { + for (String typeName: typeNames) { + String cppName = "b3OpenCLArray<" + typeName + ">"; + String javaName = typeName + "OCLArray"; + infoMap.put(new Info(cppName).pointerTypes(javaName)); + } + } + + public void map(InfoMap infoMap) { + infoMap + .put(new Info("cl_bool").cppTypes("bool")) + .put(new Info("cl_command_queue").cppTypes("cl_command_queue")) + .put(new Info("cl_command_queue_properties").cppTypes("int")) + .put(new Info("cl_context").pointerTypes("cl_context")) + .put(new Info("cl_device_id").pointerTypes("cl_device_id")) + .put(new Info("cl_device_local_mem_type").cppTypes("int")) + .put(new Info("cl_device_type").cppTypes("int")) + .put(new Info("cl_int").cppTypes("int")) + .put(new Info("cl_kernel").pointerTypes("cl_kernel")) + .put(new Info("cl_long").cppTypes("long")) + .put(new Info("cl_mem").pointerTypes("cl_mem")) + .put(new Info("cl_platform_id").pointerTypes("cl_platform_id")) + .put(new Info("cl_program").pointerTypes("cl_program")) + .put(new Info("cl_uint").cppTypes("unsigned int")) + .put(new Info("cl_ulong").cppTypes("unsigned long")) + + .put(new Info( + "DEBUG_CHECK_DEQUANTIZATION", + "b3Int64", + "b3OptimizedBvhNodeData", + "b3QuantizedBvhData", + "float4" + ).cppTypes().translate(false)) + + .put(new Info("b3AlignedObjectArray").pointerTypes("b3ConvexUtilityArray")) + .put(new Info("b3AlignedObjectArray*>").pointerTypes("b3UnsignedCharOCLArrayArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3OptimizedBvhArray")) + .put(new Info("b3AlignedObjectArray").pointerTypes("b3TriangleIndexVertexArrayArray")) + .put(new Info("b3OpenCLArray").pointerTypes("b3UnsignedCharOCLArray")) + .put(new Info("b3OpenCLArray").pointerTypes("b3IntOCLArray")) + .put(new Info("b3OpenCLArray").pointerTypes("b3UnsignedIntOCLArray")) + .put(new Info("b3OpenCLArray").pointerTypes("b3FloatOCLArray")) + .put(new Info("b3OpenCLArray").pointerTypes("b3Int4OCLArray")) + + .put(new Info("b3GpuBroadphaseInterface.h").linePatterns(".*typedef.*CreateFunc.*").skip()) + + .put(new Info( + "GpuSatCollision::m_concaveHasSeparatingNormals", + "GpuSatCollision::m_concaveSepNormals", + "GpuSatCollision::m_dmins", + "GpuSatCollision::m_gpuCompoundPairs", + "GpuSatCollision::m_gpuCompoundSepNormals", + "GpuSatCollision::m_gpuHasCompoundSepNormals", + "GpuSatCollision::m_hasSeparatingNormals", + "GpuSatCollision::m_numCompoundPairsOut", + "GpuSatCollision::m_numConcavePairsOut", + "GpuSatCollision::m_sepNormals", + "GpuSatCollision::m_totalContactsOut", + "GpuSatCollision::m_unitSphereDirections", + "b3GpuPgsConstraintSolver::sortConstraintByBatch3", + "b3GpuSapBroadphase::m_allAabbsGPU", + "b3GpuSapBroadphase::m_dst", + "b3GpuSapBroadphase::m_gpuSmallSortData", + "b3GpuSapBroadphase::m_gpuSmallSortedAabbs", + "b3GpuSapBroadphase::m_largeAabbsMappingGPU", + "b3GpuSapBroadphase::m_overlappingPairs", + "b3GpuSapBroadphase::m_pairCount", + "b3GpuSapBroadphase::m_smallAabbsMappingGPU", + "b3GpuSapBroadphase::m_sum", + "b3GpuSapBroadphase::m_sum2", + "b3Solver::m_batchSizes", + "b3Solver::m_scan" + ).skip()) + ; + + Bullet3Common.mapArrays(infoMap, + "b3BvhInfo", + "b3BvhSubtreeInfo", + "b3CompoundOverlappingPair", + "b3Contact4", + "b3GpuConstraint4", + "b3GpuGenericConstraint", + "b3InertiaData", + "b3QuantizedBvhNode", + "b3SapAabb", + "b3SortData" + ); + + mapOCLArrays(infoMap, + "b3Aabb", + "b3BvhInfo", + "b3BvhSubtreeInfo", + "b3Collidable", + "b3CompoundOverlappingPair", + "b3Contact4", + "b3ConvexPolyhedronData", + "b3GpuChildShape", + "b3GpuConstraint4", + "b3GpuFace", + "b3GpuGenericConstraint", + "b3InertiaData", + "b3Int2", + "b3Int4", + "b3QuantizedBvhNode", + "b3RayInfo", + "b3RigidBodyData", + "b3SapAabb", + "b3SortData", + "b3Vector3" + ); + } + + public static class cl_command_queue extends Pointer { + public cl_command_queue() { super((Pointer)null); } + public cl_command_queue(Pointer p) { super(p); } + } + + public static class cl_context extends Pointer { + public cl_context() { super((Pointer)null); } + public cl_context(Pointer p) { super(p); } + } + + public static class cl_device_id extends Pointer { + public cl_device_id() { super((Pointer)null); } + public cl_device_id(Pointer p) { super(p); } + } + + public static class cl_kernel extends Pointer { + public cl_kernel() { super((Pointer)null); } + public cl_kernel(Pointer p) { super(p); } + } + + public static class cl_mem extends Pointer { + public cl_mem() { super((Pointer)null); } + public cl_mem(Pointer p) { super(p); } + } + + public static class cl_platform_id extends Pointer { + public cl_platform_id() { super((Pointer)null); } + public cl_platform_id(Pointer p) { super(p); } + } + + public static class cl_program extends Pointer { + public cl_program() { super((Pointer)null); } + public cl_program(Pointer p) { super(p); } + } +} diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 79782eb8142..18a42688a5e 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -9,4 +9,5 @@ exports org.bytedeco.bullet.Bullet3Common; exports org.bytedeco.bullet.Bullet3Collision; exports org.bytedeco.bullet.Bullet3Dynamics; + exports org.bytedeco.bullet.Bullet3OpenCL; } From 0d3122cf8168b4c468b6047a8d6945fd952694e5 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 8 Mar 2022 17:56:17 +0800 Subject: [PATCH 68/81] Update generated code for bullet's preset See parent commit. --- .../bullet/Bullet3Collision/b3AabbArray.java | 4 - .../b3BroadphasePairSortPredicate.java | 2 +- .../b3HashedOverlappingPairCache.java | 10 +- .../Bullet3Collision/b3NullPairCache.java | 10 +- .../Bullet3Collision/b3OverlapCallback.java | 2 +- .../b3OverlappingPairCache.java | 10 +- .../b3SortedOverlappingPairCache.java | 10 +- .../bullet/Bullet3Collision/sStkNNArray.java | 4 + .../bullet/Bullet3Common/b3FloatArray.java | 85 + .../bullet/Bullet3Common/b3Int2Array.java | 85 + .../bullet/Bullet3Common/b3IntArray.java | 4 - .../Bullet3Common/b3UnsignedCharArray.java | 89 ++ .../Bullet3Common/b3UnsignedIntArray.java | 85 + .../Bullet3Dynamics/b3TypedConstraint.java | 2 +- .../b3TypedConstraintArray.java | 93 ++ .../bullet/Bullet3OpenCL/GpuSatCollision.java | 170 ++ .../bullet/Bullet3OpenCL/b3AabbOCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3BoundSearchCL.java | 54 + .../bullet/Bullet3OpenCL/b3BufferInfoCL.java | 36 + .../bullet/Bullet3OpenCL/b3BvhInfo.java | 45 + .../bullet/Bullet3OpenCL/b3BvhInfoArray.java | 91 ++ .../Bullet3OpenCL/b3BvhInfoOCLArray.java | 76 + .../Bullet3OpenCL/b3BvhSubtreeInfo.java | 41 + .../Bullet3OpenCL/b3BvhSubtreeInfoArray.java | 91 ++ .../b3BvhSubtreeInfoOCLArray.java | 76 + .../Bullet3OpenCL/b3CharIndexTripletData.java | 41 + .../Bullet3OpenCL/b3CollidableOCLArray.java | 76 + .../b3CompoundOverlappingPairArray.java | 91 ++ .../b3CompoundOverlappingPairOCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3Contact4Array.java | 91 ++ .../Bullet3OpenCL/b3Contact4OCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3ContactCache.java | 61 + .../bullet/Bullet3OpenCL/b3ContactPoint.java | 25 + .../b3ConvexPolyhedronDataOCLArray.java | 76 + .../Bullet3OpenCL/b3ConvexUtilityArray.java | 95 ++ .../bullet/Bullet3OpenCL/b3Dispatcher.java | 26 + .../bullet/Bullet3OpenCL/b3FillCL.java | 70 + .../bullet/Bullet3OpenCL/b3FloatOCLArray.java | 84 + .../bullet/Bullet3OpenCL/b3GjkEpaSolver2.java | 92 ++ .../Bullet3OpenCL/b3GjkPairDetector.java | 26 + .../b3GpuBroadphaseInterface.java | 46 + .../b3GpuChildShapeOCLArray.java | 76 + .../Bullet3OpenCL/b3GpuConstraint4.java | 41 + .../Bullet3OpenCL/b3GpuConstraint4Array.java | 91 ++ .../b3GpuConstraint4OCLArray.java | 76 + .../Bullet3OpenCL/b3GpuConstraintInfo2.java | 75 + .../Bullet3OpenCL/b3GpuFaceOCLArray.java | 76 + .../Bullet3OpenCL/b3GpuGenericConstraint.java | 70 + .../b3GpuGenericConstraintArray.java | 91 ++ .../b3GpuGenericConstraintOCLArray.java | 76 + .../Bullet3OpenCL/b3GpuGridBroadphase.java | 50 + .../b3GpuJacobiContactSolver.java | 36 + .../Bullet3OpenCL/b3GpuNarrowPhase.java | 101 ++ .../b3GpuNarrowPhaseInternalData.java | 99 ++ .../Bullet3OpenCL/b3GpuParallelLinearBvh.java | 62 + .../b3GpuParallelLinearBvhBroadphase.java | 51 + .../b3GpuPgsConstraintSolver.java | 39 + .../Bullet3OpenCL/b3GpuPgsContactSolver.java | 30 + .../bullet/Bullet3OpenCL/b3GpuRaycast.java | 36 + .../Bullet3OpenCL/b3GpuRigidBodyPipeline.java | 69 + .../b3GpuRigidBodyPipelineInternalData.java | 70 + .../Bullet3OpenCL/b3GpuSapBroadphase.java | 94 ++ .../bullet/Bullet3OpenCL/b3GpuSolverBody.java | 114 ++ .../Bullet3OpenCL/b3GpuSolverConstraint.java | 76 + .../bullet/Bullet3OpenCL/b3IndexedMesh.java | 58 + .../Bullet3OpenCL/b3InertiaDataArray.java | 91 ++ .../Bullet3OpenCL/b3InertiaDataOCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3Int2OCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3Int4OCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3IntIndexData.java | 39 + .../bullet/Bullet3OpenCL/b3IntOCLArray.java | 84 + .../b3InternalTriangleIndexCallback.java | 27 + .../Bullet3OpenCL/b3JacobiSolverInfo.java | 47 + .../bullet/Bullet3OpenCL/b3KernelArgData.java | 44 + .../bullet/Bullet3OpenCL/b3LauncherCL.java | 64 + .../bullet/Bullet3OpenCL/b3MeshPartData.java | 50 + .../Bullet3OpenCL/b3NodeOverlapCallback.java | 28 + .../Bullet3OpenCL/b3OpenCLDeviceInfo.java | 78 + .../Bullet3OpenCL/b3OpenCLPlatformInfo.java | 44 + .../bullet/Bullet3OpenCL/b3OpenCLUtils.java | 98 ++ .../bullet/Bullet3OpenCL/b3OptimizedBvh.java | 52 + .../Bullet3OpenCL/b3OptimizedBvhArray.java | 91 ++ .../Bullet3OpenCL/b3OptimizedBvhNode.java | 56 + .../b3OptimizedBvhNodeDoubleData.java | 45 + .../b3OptimizedBvhNodeFloatData.java | 45 + .../b3ParamsGridBroadphaseCL.java | 46 + .../Bullet3OpenCL/b3PrefixScanFloat4CL.java | 34 + .../bullet/Bullet3OpenCL/b3QuantizedBvh.java | 108 ++ .../b3QuantizedBvhDoubleData.java | 51 + .../b3QuantizedBvhFloatData.java | 50 + .../Bullet3OpenCL/b3QuantizedBvhNode.java | 45 + .../b3QuantizedBvhNodeArray.java | 91 ++ .../b3QuantizedBvhNodeOCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3RadixSort32CL.java | 80 + .../Bullet3OpenCL/b3RayInfoOCLArray.java | 76 + .../b3RigidBodyDataOCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3SapAabb.java | 27 + .../bullet/Bullet3OpenCL/b3SapAabbArray.java | 91 ++ .../Bullet3OpenCL/b3SapAabbOCLArray.java | 76 + .../bullet/Bullet3OpenCL/b3Serializer.java | 26 + .../Bullet3OpenCL/b3ShortIntIndexData.java | 41 + .../b3ShortIntIndexTripletData.java | 42 + .../bullet/Bullet3OpenCL/b3Solver.java | 70 + .../bullet/Bullet3OpenCL/b3SolverBase.java | 55 + .../bullet/Bullet3OpenCL/b3SortData.java | 42 + .../bullet/Bullet3OpenCL/b3SortDataArray.java | 91 ++ .../Bullet3OpenCL/b3SortDataOCLArray.java | 76 + .../b3StridingMeshInterface.java | 80 + .../b3StridingMeshInterfaceData.java | 44 + .../b3SubSimplexClosestResult.java | 51 + .../Bullet3OpenCL/b3TriangleCallback.java | 29 + .../b3TriangleIndexVertexArray.java | 88 ++ .../b3TriangleIndexVertexArrayArray.java | 91 ++ .../Bullet3OpenCL/b3UnsignedCharOCLArray.java | 84 + .../b3UnsignedCharOCLArrayArray.java | 91 ++ .../Bullet3OpenCL/b3UnsignedIntOCLArray.java | 84 + .../bullet/Bullet3OpenCL/b3UsageBitfield.java | 47 + .../Bullet3OpenCL/b3Vector3OCLArray.java | 76 + .../Bullet3OpenCL/b3VoronoiSimplexSolver.java | 94 ++ .../bullet/global/Bullet3Collision.java | 14 +- .../bytedeco/bullet/global/Bullet3Common.java | 12 + .../bullet/global/Bullet3Dynamics.java | 47 + .../bytedeco/bullet/global/Bullet3OpenCL.java | 1378 +++++++++++++++++ 123 files changed, 8813 insertions(+), 38 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3FloatArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int2Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedCharArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedIntArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactCache.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3AabbArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3AabbArray.java index d6d536e158c..5b11e6f5cab 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3AabbArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3AabbArray.java @@ -11,11 +11,7 @@ import static org.bytedeco.bullet.global.Bullet3Common.*; import static org.bytedeco.bullet.global.Bullet3Collision.*; - //for placement new -// #endif //B3_USE_PLACEMENT_NEW -/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) public class b3AabbArray extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphasePairSortPredicate.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphasePairSortPredicate.java index 228a8afc81a..20c5c61a4e8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphasePairSortPredicate.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3BroadphasePairSortPredicate.java @@ -38,5 +38,5 @@ public class b3BroadphasePairSortPredicate extends Pointer { return new b3BroadphasePairSortPredicate((Pointer)this).offsetAddress(i); } - public native @Cast("bool") @Name("operator ()") boolean apply(@Cast("const b3BroadphasePair*") @ByRef b3Int4 a, @Cast("const b3BroadphasePair*") @ByRef b3Int4 b); + public native @Cast("bool") @Name("operator ()") boolean apply(@Const @ByRef b3Int4 a, @Const @ByRef b3Int4 b); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3HashedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3HashedOverlappingPairCache.java index 3f5135e73a4..fe806174bb8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3HashedOverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3HashedOverlappingPairCache.java @@ -40,19 +40,19 @@ public class b3HashedOverlappingPairCache extends b3OverlappingPairCache { // Add a pair and return the new pair. If the pair already exists, // no new pair is created and the old one is returned. - public native @Cast("b3BroadphasePair*") b3Int4 addOverlappingPair(int proxy0, int proxy1); + public native b3Int4 addOverlappingPair(int proxy0, int proxy1); public native void cleanProxyFromPairs(int proxy, b3Dispatcher dispatcher); public native void processAllOverlappingPairs(b3OverlapCallback arg0, b3Dispatcher dispatcher); - public native @Cast("b3BroadphasePair*") b3Int4 getOverlappingPairArrayPtr(); + public native b3Int4 getOverlappingPairArrayPtr(); - public native @Cast("b3BroadphasePairArray*") @ByRef b3AabbArray getOverlappingPairArray(); + public native @Cast("b3BroadphasePairArray*") @ByRef b3Int4Array getOverlappingPairArray(); - public native void cleanOverlappingPair(@Cast("b3BroadphasePair*") @ByRef b3Int4 pair, b3Dispatcher dispatcher); + public native void cleanOverlappingPair(@ByRef b3Int4 pair, b3Dispatcher dispatcher); - public native @Cast("b3BroadphasePair*") b3Int4 findPair(int proxy0, int proxy1); + public native b3Int4 findPair(int proxy0, int proxy1); public native int GetCount(); // b3BroadphasePair* GetPairs() { return m_pairs; } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3NullPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3NullPairCache.java index 3885c934f6c..ed92298eec2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3NullPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3NullPairCache.java @@ -32,10 +32,10 @@ public class b3NullPairCache extends b3OverlappingPairCache { return new b3NullPairCache((Pointer)this).offsetAddress(i); } - public native @Cast("b3BroadphasePair*") b3Int4 getOverlappingPairArrayPtr(); - public native @Cast("b3BroadphasePairArray*") @ByRef b3AabbArray getOverlappingPairArray(); + public native b3Int4 getOverlappingPairArrayPtr(); + public native @Cast("b3BroadphasePairArray*") @ByRef b3Int4Array getOverlappingPairArray(); - public native void cleanOverlappingPair(@Cast("b3BroadphasePair*") @ByRef b3Int4 arg0, b3Dispatcher arg1); + public native void cleanOverlappingPair(@ByRef b3Int4 arg0, b3Dispatcher arg1); public native int getNumOverlappingPairs(); @@ -45,7 +45,7 @@ public class b3NullPairCache extends b3OverlappingPairCache { public native void processAllOverlappingPairs(b3OverlapCallback arg0, b3Dispatcher arg1); - public native @Cast("b3BroadphasePair*") b3Int4 findPair(int arg0, int arg1); + public native b3Int4 findPair(int arg0, int arg1); public native @Cast("bool") boolean hasDeferredRemoval(); @@ -54,7 +54,7 @@ public class b3NullPairCache extends b3OverlappingPairCache { // // } - public native @Cast("b3BroadphasePair*") b3Int4 addOverlappingPair(int arg0, int arg1); + public native b3Int4 addOverlappingPair(int arg0, int arg1); public native Pointer removeOverlappingPair(int arg0, int arg1, b3Dispatcher arg2); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapCallback.java index 168e908c99f..50974a2d435 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlapCallback.java @@ -20,5 +20,5 @@ public class b3OverlapCallback extends Pointer { public b3OverlapCallback(Pointer p) { super(p); } //return true for deletion of the pair - public native @Cast("bool") boolean processOverlap(@Cast("b3BroadphasePair*") @ByRef b3Int4 pair); + public native @Cast("bool") boolean processOverlap(@ByRef b3Int4 pair); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlappingPairCache.java index 6dfd35e7610..de137eb4df7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3OverlappingPairCache.java @@ -22,11 +22,11 @@ public class b3OverlappingPairCache extends Pointer { public b3OverlappingPairCache(Pointer p) { super(p); } // this is needed so we can get to the derived class destructor - public native @Cast("b3BroadphasePair*") b3Int4 getOverlappingPairArrayPtr(); + public native b3Int4 getOverlappingPairArrayPtr(); - public native @Cast("b3BroadphasePairArray*") @ByRef b3AabbArray getOverlappingPairArray(); + public native @Cast("b3BroadphasePairArray*") @ByRef b3Int4Array getOverlappingPairArray(); - public native void cleanOverlappingPair(@Cast("b3BroadphasePair*") @ByRef b3Int4 pair, b3Dispatcher dispatcher); + public native void cleanOverlappingPair(@ByRef b3Int4 pair, b3Dispatcher dispatcher); public native int getNumOverlappingPairs(); @@ -36,13 +36,13 @@ public class b3OverlappingPairCache extends Pointer { public native void processAllOverlappingPairs(b3OverlapCallback arg0, b3Dispatcher dispatcher); - public native @Cast("b3BroadphasePair*") b3Int4 findPair(int proxy0, int proxy1); + public native b3Int4 findPair(int proxy0, int proxy1); public native @Cast("bool") boolean hasDeferredRemoval(); //virtual void setInternalGhostPairCallback(b3OverlappingPairCallback* ghostPairCallback)=0; - public native @Cast("b3BroadphasePair*") b3Int4 addOverlappingPair(int proxy0, int proxy1); + public native b3Int4 addOverlappingPair(int proxy0, int proxy1); public native Pointer removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher dispatcher); public native void removeOverlappingPairsContainingProxy(int arg0, b3Dispatcher arg1); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3SortedOverlappingPairCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3SortedOverlappingPairCache.java index 43da0f7a452..fe78d0e1950 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3SortedOverlappingPairCache.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3SortedOverlappingPairCache.java @@ -37,11 +37,11 @@ public class b3SortedOverlappingPairCache extends b3OverlappingPairCache { public native Pointer removeOverlappingPair(int proxy0, int proxy1, b3Dispatcher dispatcher); - public native void cleanOverlappingPair(@Cast("b3BroadphasePair*") @ByRef b3Int4 pair, b3Dispatcher dispatcher); + public native void cleanOverlappingPair(@ByRef b3Int4 pair, b3Dispatcher dispatcher); - public native @Cast("b3BroadphasePair*") b3Int4 addOverlappingPair(int proxy0, int proxy1); + public native b3Int4 addOverlappingPair(int proxy0, int proxy1); - public native @Cast("b3BroadphasePair*") b3Int4 findPair(int proxy0, int proxy1); + public native b3Int4 findPair(int proxy0, int proxy1); public native void cleanProxyFromPairs(int proxy, b3Dispatcher dispatcher); @@ -49,9 +49,9 @@ public class b3SortedOverlappingPairCache extends b3OverlappingPairCache { public native @Cast("bool") boolean needsBroadphaseCollision(int proxy0, int proxy1); - public native @Cast("b3BroadphasePairArray*") @ByRef b3AabbArray getOverlappingPairArray(); + public native @Cast("b3BroadphasePairArray*") @ByRef b3Int4Array getOverlappingPairArray(); - public native @Cast("b3BroadphasePair*") b3Int4 getOverlappingPairArrayPtr(); + public native b3Int4 getOverlappingPairArrayPtr(); public native int getNumOverlappingPairs(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNNArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNNArray.java index 3b085f696d6..dda262f57f0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNNArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/sStkNNArray.java @@ -11,7 +11,11 @@ import static org.bytedeco.bullet.global.Bullet3Common.*; import static org.bytedeco.bullet.global.Bullet3Collision.*; + //for placement new +// #endif //B3_USE_PLACEMENT_NEW +/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Collision.class) public class sStkNNArray extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3FloatArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3FloatArray.java new file mode 100644 index 00000000000..e5e6dc34603 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3FloatArray.java @@ -0,0 +1,85 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3FloatArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3FloatArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3FloatArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3FloatArray position(long position) { + return (b3FloatArray)super.position(position); + } + @Override public b3FloatArray getPointer(long i) { + return new b3FloatArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3FloatArray put(@Const @ByRef b3FloatArray other); + public b3FloatArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3FloatArray(@Const @ByRef b3FloatArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3FloatArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef FloatPointer at(int n); + + public native @ByRef @Name("operator []") FloatPointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, float fillData/*=float()*/); + public native void resize(int newsize); + public native @ByRef FloatPointer expandNonInitializing(); + + public native @ByRef FloatPointer expand(float fillValue/*=float()*/); + public native @ByRef FloatPointer expand(); + + public native void push_back(float _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(float key); + + public native int findLinearSearch(float key); + + public native int findLinearSearch2(float key); + + public native void remove(float key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3FloatArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int2Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int2Array.java new file mode 100644 index 00000000000..71943f69c46 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3Int2Array.java @@ -0,0 +1,85 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3Int2Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Int2Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Int2Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Int2Array position(long position) { + return (b3Int2Array)super.position(position); + } + @Override public b3Int2Array getPointer(long i) { + return new b3Int2Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3Int2Array put(@Const @ByRef b3Int2Array other); + public b3Int2Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3Int2Array(@Const @ByRef b3Int2Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3Int2Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3Int2 at(int n); + + public native @ByRef @Name("operator []") b3Int2 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3Int2()") b3Int2 fillData); + public native void resize(int newsize); + public native @ByRef b3Int2 expandNonInitializing(); + + public native @ByRef b3Int2 expand(@Const @ByRef(nullValue = "b3Int2()") b3Int2 fillValue); + public native @ByRef b3Int2 expand(); + + public native void push_back(@Const @ByRef b3Int2 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3Int2Array otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3IntArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3IntArray.java index 6703b7f9ff8..f6694ea041e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3IntArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3IntArray.java @@ -9,11 +9,7 @@ import static org.bytedeco.javacpp.presets.javacpp.*; import static org.bytedeco.bullet.global.Bullet3Common.*; - //for placement new -// #endif //B3_USE_PLACEMENT_NEW -/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods - * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ @Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) public class b3IntArray extends Pointer { static { Loader.load(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedCharArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedCharArray.java new file mode 100644 index 00000000000..fb4fed41298 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedCharArray.java @@ -0,0 +1,89 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + //for placement new +// #endif //B3_USE_PLACEMENT_NEW + +/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3UnsignedCharArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3UnsignedCharArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3UnsignedCharArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3UnsignedCharArray position(long position) { + return (b3UnsignedCharArray)super.position(position); + } + @Override public b3UnsignedCharArray getPointer(long i) { + return new b3UnsignedCharArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3UnsignedCharArray put(@Const @ByRef b3UnsignedCharArray other); + public b3UnsignedCharArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3UnsignedCharArray(@Const @ByRef b3UnsignedCharArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3UnsignedCharArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @Cast("unsigned char*") @ByRef BytePointer at(int n); + + public native @Cast("unsigned char*") @ByRef @Name("operator []") BytePointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Cast("const unsigned char") byte fillData/*=unsigned char()*/); + public native void resize(int newsize); + public native @Cast("unsigned char*") @ByRef BytePointer expandNonInitializing(); + + public native @Cast("unsigned char*") @ByRef BytePointer expand(@Cast("const unsigned char") byte fillValue/*=unsigned char()*/); + public native @Cast("unsigned char*") @ByRef BytePointer expand(); + + public native void push_back(@Cast("const unsigned char") byte _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Cast("const unsigned char") byte key); + + public native int findLinearSearch(@Cast("const unsigned char") byte key); + + public native int findLinearSearch2(@Cast("const unsigned char") byte key); + + public native void remove(@Cast("const unsigned char") byte key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3UnsignedCharArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedIntArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedIntArray.java new file mode 100644 index 00000000000..5a87d94700d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Common/b3UnsignedIntArray.java @@ -0,0 +1,85 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Common; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +import static org.bytedeco.bullet.global.Bullet3Common.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Common.class) +public class b3UnsignedIntArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3UnsignedIntArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3UnsignedIntArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3UnsignedIntArray position(long position) { + return (b3UnsignedIntArray)super.position(position); + } + @Override public b3UnsignedIntArray getPointer(long i) { + return new b3UnsignedIntArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3UnsignedIntArray put(@Const @ByRef b3UnsignedIntArray other); + public b3UnsignedIntArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3UnsignedIntArray(@Const @ByRef b3UnsignedIntArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3UnsignedIntArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @Cast("unsigned int*") @ByRef IntPointer at(int n); + + public native @Cast("unsigned int*") @ByRef @Name("operator []") IntPointer get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Cast("const unsigned int") int fillData/*=unsigned int()*/); + public native void resize(int newsize); + public native @Cast("unsigned int*") @ByRef IntPointer expandNonInitializing(); + + public native @Cast("unsigned int*") @ByRef IntPointer expand(@Cast("const unsigned int") int fillValue/*=unsigned int()*/); + public native @Cast("unsigned int*") @ByRef IntPointer expand(); + + public native void push_back(@Cast("const unsigned int") int _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@Cast("const unsigned int") int key); + + public native int findLinearSearch(@Cast("const unsigned int") int key); + + public native int findLinearSearch2(@Cast("const unsigned int") int key); + + public native void remove(@Cast("const unsigned int") int key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3UnsignedIntArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraint.java index e1081f86f24..8b52ad8f88c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraint.java @@ -107,7 +107,7 @@ public static class b3ConstraintInfo2 extends Pointer { public native void setOverrideNumSolverIterations(int overideNumIterations); /**internal method used by the constraint solver, don't use them directly */ - public native void setupSolverConstraint(@Cast("b3ConstraintArray*") @ByRef b3IntArray ca, int solverBodyA, int solverBodyB, @Cast("b3Scalar") float timeStep); + public native void setupSolverConstraint(@Cast("b3ConstraintArray*") @ByRef b3TypedConstraintArray ca, int solverBodyA, int solverBodyB, @Cast("b3Scalar") float timeStep); /**internal method used by the constraint solver, don't use them directly */ public native void getInfo1(b3ConstraintInfo1 info, @Const b3RigidBodyData bodies); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraintArray.java new file mode 100644 index 00000000000..ba837acb876 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TypedConstraintArray.java @@ -0,0 +1,93 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3Dynamics; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; + +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + //for placement new +// #endif //B3_USE_PLACEMENT_NEW + +/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3Dynamics.class) +public class b3TypedConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TypedConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3TypedConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3TypedConstraintArray position(long position) { + return (b3TypedConstraintArray)super.position(position); + } + @Override public b3TypedConstraintArray getPointer(long i) { + return new b3TypedConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3TypedConstraintArray put(@Const @ByRef b3TypedConstraintArray other); + public b3TypedConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3TypedConstraintArray(@Const @ByRef b3TypedConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3TypedConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef b3TypedConstraint at(int n); + + public native @ByPtrRef @Name("operator []") b3TypedConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef b3TypedConstraint fillData/*=b3TypedConstraint*()*/); + public native void resize(int newsize); + public native @ByPtrRef b3TypedConstraint expandNonInitializing(); + + public native @ByPtrRef b3TypedConstraint expand(@ByPtrRef b3TypedConstraint fillValue/*=b3TypedConstraint*()*/); + public native @ByPtrRef b3TypedConstraint expand(); + + public native void push_back(@ByPtrRef b3TypedConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef b3TypedConstraint key); + + public native int findLinearSearch(@ByPtrRef b3TypedConstraint key); + + public native int findLinearSearch2(@ByPtrRef b3TypedConstraint key); + + public native void remove(@ByPtrRef b3TypedConstraint key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3TypedConstraintArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java new file mode 100644 index 00000000000..16cb0f62529 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java @@ -0,0 +1,170 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +//#include "../../dynamics/basic_demo/Stubs/ChNarrowPhase.h" + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class GpuSatCollision extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public GpuSatCollision(Pointer p) { super(p); } + + public native @ByRef cl_context m_context(); public native GpuSatCollision m_context(cl_context setter); + public native @ByRef cl_device_id m_device(); public native GpuSatCollision m_device(cl_device_id setter); + public native @ByRef cl_command_queue m_queue(); public native GpuSatCollision m_queue(cl_command_queue setter); + public native @ByRef cl_kernel m_findSeparatingAxisKernel(); public native GpuSatCollision m_findSeparatingAxisKernel(cl_kernel setter); + public native @ByRef cl_kernel m_mprPenetrationKernel(); public native GpuSatCollision m_mprPenetrationKernel(cl_kernel setter); + public native @ByRef cl_kernel m_findSeparatingAxisUnitSphereKernel(); public native GpuSatCollision m_findSeparatingAxisUnitSphereKernel(cl_kernel setter); + + public native @ByRef cl_kernel m_findSeparatingAxisVertexFaceKernel(); public native GpuSatCollision m_findSeparatingAxisVertexFaceKernel(cl_kernel setter); + public native @ByRef cl_kernel m_findSeparatingAxisEdgeEdgeKernel(); public native GpuSatCollision m_findSeparatingAxisEdgeEdgeKernel(cl_kernel setter); + + public native @ByRef cl_kernel m_findConcaveSeparatingAxisKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisKernel(cl_kernel setter); + public native @ByRef cl_kernel m_findConcaveSeparatingAxisVertexFaceKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisVertexFaceKernel(cl_kernel setter); + public native @ByRef cl_kernel m_findConcaveSeparatingAxisEdgeEdgeKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisEdgeEdgeKernel(cl_kernel setter); + + public native @ByRef cl_kernel m_findCompoundPairsKernel(); public native GpuSatCollision m_findCompoundPairsKernel(cl_kernel setter); + public native @ByRef cl_kernel m_processCompoundPairsKernel(); public native GpuSatCollision m_processCompoundPairsKernel(cl_kernel setter); + + public native @ByRef cl_kernel m_clipHullHullKernel(); public native GpuSatCollision m_clipHullHullKernel(cl_kernel setter); + public native @ByRef cl_kernel m_clipCompoundsHullHullKernel(); public native GpuSatCollision m_clipCompoundsHullHullKernel(cl_kernel setter); + + public native @ByRef cl_kernel m_clipFacesAndFindContacts(); public native GpuSatCollision m_clipFacesAndFindContacts(cl_kernel setter); + public native @ByRef cl_kernel m_findClippingFacesKernel(); public native GpuSatCollision m_findClippingFacesKernel(cl_kernel setter); + + public native @ByRef cl_kernel m_clipHullHullConcaveConvexKernel(); public native GpuSatCollision m_clipHullHullConcaveConvexKernel(cl_kernel setter); + // cl_kernel m_extractManifoldAndAddContactKernel; + public native @ByRef cl_kernel m_newContactReductionKernel(); public native GpuSatCollision m_newContactReductionKernel(cl_kernel setter); + + public native @ByRef cl_kernel m_bvhTraversalKernel(); public native GpuSatCollision m_bvhTraversalKernel(cl_kernel setter); + public native @ByRef cl_kernel m_primitiveContactsKernel(); public native GpuSatCollision m_primitiveContactsKernel(cl_kernel setter); + public native @ByRef cl_kernel m_findConcaveSphereContactsKernel(); public native GpuSatCollision m_findConcaveSphereContactsKernel(cl_kernel setter); + + public native @ByRef cl_kernel m_processCompoundPairsPrimitivesKernel(); public native GpuSatCollision m_processCompoundPairsPrimitivesKernel(cl_kernel setter); + + + + + + + + + + + + + + + + + + public GpuSatCollision(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q) { super((Pointer)null); allocate(ctx, device, q); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + + public native void computeConvexConvexContactsGPUSAT(b3Int4OCLArray pairs, int nPairs, + @Const b3RigidBodyDataOCLArray bodyBuf, + b3Contact4OCLArray contactOut, @ByRef IntPointer nContacts, + @Const b3Contact4OCLArray oldContacts, + int maxContactCapacity, + int compoundPairCapacity, + @Const @ByRef b3ConvexPolyhedronDataOCLArray hostConvexData, + @Const @ByRef b3Vector3OCLArray vertices, + @Const @ByRef b3Vector3OCLArray uniqueEdges, + @Const @ByRef b3GpuFaceOCLArray faces, + @Const @ByRef b3IntOCLArray indices, + @Const @ByRef b3CollidableOCLArray gpuCollidables, + @Const @ByRef b3GpuChildShapeOCLArray gpuChildShapes, + + @Const @ByRef b3AabbOCLArray clAabbsWorldSpace, + @Const @ByRef b3AabbOCLArray clAabbsLocalSpace, + + @ByRef b3Vector3OCLArray worldVertsB1GPU, + @ByRef b3Int4OCLArray clippingFacesOutGPU, + @ByRef b3Vector3OCLArray worldNormalsAGPU, + @ByRef b3Vector3OCLArray worldVertsA1GPU, + @ByRef b3Vector3OCLArray worldVertsB2GPU, + @ByRef b3OptimizedBvhArray bvhData, + b3QuantizedBvhNodeOCLArray treeNodesGPU, + b3BvhSubtreeInfoOCLArray subTreesGPU, + b3BvhInfoOCLArray bvhInfo, + int numObjects, + int maxTriConvexPairCapacity, + @ByRef b3Int4OCLArray triangleConvexPairs, + @ByRef IntPointer numTriConvexPairsOut); + public native void computeConvexConvexContactsGPUSAT(b3Int4OCLArray pairs, int nPairs, + @Const b3RigidBodyDataOCLArray bodyBuf, + b3Contact4OCLArray contactOut, @ByRef IntBuffer nContacts, + @Const b3Contact4OCLArray oldContacts, + int maxContactCapacity, + int compoundPairCapacity, + @Const @ByRef b3ConvexPolyhedronDataOCLArray hostConvexData, + @Const @ByRef b3Vector3OCLArray vertices, + @Const @ByRef b3Vector3OCLArray uniqueEdges, + @Const @ByRef b3GpuFaceOCLArray faces, + @Const @ByRef b3IntOCLArray indices, + @Const @ByRef b3CollidableOCLArray gpuCollidables, + @Const @ByRef b3GpuChildShapeOCLArray gpuChildShapes, + + @Const @ByRef b3AabbOCLArray clAabbsWorldSpace, + @Const @ByRef b3AabbOCLArray clAabbsLocalSpace, + + @ByRef b3Vector3OCLArray worldVertsB1GPU, + @ByRef b3Int4OCLArray clippingFacesOutGPU, + @ByRef b3Vector3OCLArray worldNormalsAGPU, + @ByRef b3Vector3OCLArray worldVertsA1GPU, + @ByRef b3Vector3OCLArray worldVertsB2GPU, + @ByRef b3OptimizedBvhArray bvhData, + b3QuantizedBvhNodeOCLArray treeNodesGPU, + b3BvhSubtreeInfoOCLArray subTreesGPU, + b3BvhInfoOCLArray bvhInfo, + int numObjects, + int maxTriConvexPairCapacity, + @ByRef b3Int4OCLArray triangleConvexPairs, + @ByRef IntBuffer numTriConvexPairsOut); + public native void computeConvexConvexContactsGPUSAT(b3Int4OCLArray pairs, int nPairs, + @Const b3RigidBodyDataOCLArray bodyBuf, + b3Contact4OCLArray contactOut, @ByRef int[] nContacts, + @Const b3Contact4OCLArray oldContacts, + int maxContactCapacity, + int compoundPairCapacity, + @Const @ByRef b3ConvexPolyhedronDataOCLArray hostConvexData, + @Const @ByRef b3Vector3OCLArray vertices, + @Const @ByRef b3Vector3OCLArray uniqueEdges, + @Const @ByRef b3GpuFaceOCLArray faces, + @Const @ByRef b3IntOCLArray indices, + @Const @ByRef b3CollidableOCLArray gpuCollidables, + @Const @ByRef b3GpuChildShapeOCLArray gpuChildShapes, + + @Const @ByRef b3AabbOCLArray clAabbsWorldSpace, + @Const @ByRef b3AabbOCLArray clAabbsLocalSpace, + + @ByRef b3Vector3OCLArray worldVertsB1GPU, + @ByRef b3Int4OCLArray clippingFacesOutGPU, + @ByRef b3Vector3OCLArray worldNormalsAGPU, + @ByRef b3Vector3OCLArray worldVertsA1GPU, + @ByRef b3Vector3OCLArray worldVertsB2GPU, + @ByRef b3OptimizedBvhArray bvhData, + b3QuantizedBvhNodeOCLArray treeNodesGPU, + b3BvhSubtreeInfoOCLArray subTreesGPU, + b3BvhInfoOCLArray bvhInfo, + int numObjects, + int maxTriConvexPairCapacity, + @ByRef b3Int4OCLArray triangleConvexPairs, + @ByRef int[] numTriConvexPairsOut); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java new file mode 100644 index 00000000000..5c84cdd88c9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3AabbOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3AabbOCLArray(Pointer p) { super(p); } + + public b3AabbOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3AabbOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3Aabb _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3Aabb _Val); + + public native @ByVal b3Aabb forcedAt(@Cast("size_t") long n); + + public native @ByVal b3Aabb at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3AabbArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3AabbArray srcArray); + + public native void copyFromHostPointer(@Const b3Aabb src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3Aabb src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3AabbArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3AabbArray destArray); + + public native void copyToHostPointer(b3Aabb destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3Aabb destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3AabbOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java new file mode 100644 index 00000000000..31794770d39 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java @@ -0,0 +1,54 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + //for b3SortData (perhaps move it?) +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3BoundSearchCL extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BoundSearchCL(Pointer p) { super(p); } + + /** enum b3BoundSearchCL::Option */ + public static final int + BOUND_LOWER = 0, + BOUND_UPPER = 1, + COUNT = 2; + + public native @ByRef cl_context m_context(); public native b3BoundSearchCL m_context(cl_context setter); + public native @ByRef cl_device_id m_device(); public native b3BoundSearchCL m_device(cl_device_id setter); + public native @ByRef cl_command_queue m_queue(); public native b3BoundSearchCL m_queue(cl_command_queue setter); + + public native @ByRef cl_kernel m_lowerSortDataKernel(); public native b3BoundSearchCL m_lowerSortDataKernel(cl_kernel setter); + public native @ByRef cl_kernel m_upperSortDataKernel(); public native b3BoundSearchCL m_upperSortDataKernel(cl_kernel setter); + public native @ByRef cl_kernel m_subtractKernel(); public native b3BoundSearchCL m_subtractKernel(cl_kernel setter); + + public native b3Int4OCLArray m_constbtOpenCLArray(); public native b3BoundSearchCL m_constbtOpenCLArray(b3Int4OCLArray setter); + public native b3UnsignedIntOCLArray m_lower(); public native b3BoundSearchCL m_lower(b3UnsignedIntOCLArray setter); + public native b3UnsignedIntOCLArray m_upper(); public native b3BoundSearchCL m_upper(b3UnsignedIntOCLArray setter); + + public native b3FillCL m_filler(); public native b3BoundSearchCL m_filler(b3FillCL setter); + + public b3BoundSearchCL(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int size) { super((Pointer)null); allocate(context, device, queue, size); } + private native void allocate(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int size); + + // src has to be src[i].m_key <= src[i+1].m_key + public native void execute(@ByRef b3SortDataOCLArray src, int nSrc, @ByRef b3UnsignedIntOCLArray dst, int nDst, @Cast("b3BoundSearchCL::Option") int option/*=b3BoundSearchCL::BOUND_LOWER*/); + public native void execute(@ByRef b3SortDataOCLArray src, int nSrc, @ByRef b3UnsignedIntOCLArray dst, int nDst); + + public native void executeHost(@ByRef b3SortDataArray src, int nSrc, @ByRef b3UnsignedIntArray dst, int nDst, @Cast("b3BoundSearchCL::Option") int option/*=b3BoundSearchCL::BOUND_LOWER*/); + public native void executeHost(@ByRef b3SortDataArray src, int nSrc, @ByRef b3UnsignedIntArray dst, int nDst); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java new file mode 100644 index 00000000000..fc5e5d80dbc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3BufferInfoCL extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BufferInfoCL(Pointer p) { super(p); } + + //b3BufferInfoCL(){} + + // template + public b3BufferInfoCL(@ByVal cl_mem buff, @Cast("bool") boolean isReadOnly/*=false*/) { super((Pointer)null); allocate(buff, isReadOnly); } + private native void allocate(@ByVal cl_mem buff, @Cast("bool") boolean isReadOnly/*=false*/); + public b3BufferInfoCL(@ByVal cl_mem buff) { super((Pointer)null); allocate(buff); } + private native void allocate(@ByVal cl_mem buff); + + public native @ByRef cl_mem m_clBuffer(); public native b3BufferInfoCL m_clBuffer(cl_mem setter); + public native @Cast("bool") boolean m_isReadOnly(); public native b3BufferInfoCL m_isReadOnly(boolean setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java new file mode 100644 index 00000000000..1e052b2c0f6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3BvhInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3BvhInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3BvhInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BvhInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3BvhInfo position(long position) { + return (b3BvhInfo)super.position(position); + } + @Override public b3BvhInfo getPointer(long i) { + return new b3BvhInfo((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_aabbMin(); public native b3BvhInfo m_aabbMin(b3Vector3 setter); + public native @ByRef b3Vector3 m_aabbMax(); public native b3BvhInfo m_aabbMax(b3Vector3 setter); + public native @ByRef b3Vector3 m_quantization(); public native b3BvhInfo m_quantization(b3Vector3 setter); + public native int m_numNodes(); public native b3BvhInfo m_numNodes(int setter); + public native int m_numSubTrees(); public native b3BvhInfo m_numSubTrees(int setter); + public native int m_nodeOffset(); public native b3BvhInfo m_nodeOffset(int setter); + public native int m_subTreeOffset(); public native b3BvhInfo m_subTreeOffset(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java new file mode 100644 index 00000000000..23a74e7cb51 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3BvhInfoArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BvhInfoArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3BvhInfoArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3BvhInfoArray position(long position) { + return (b3BvhInfoArray)super.position(position); + } + @Override public b3BvhInfoArray getPointer(long i) { + return new b3BvhInfoArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3BvhInfoArray put(@Const @ByRef b3BvhInfoArray other); + public b3BvhInfoArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3BvhInfoArray(@Const @ByRef b3BvhInfoArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3BvhInfoArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3BvhInfo at(int n); + + public native @ByRef @Name("operator []") b3BvhInfo get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3BvhInfo()") b3BvhInfo fillData); + public native void resize(int newsize); + public native @ByRef b3BvhInfo expandNonInitializing(); + + public native @ByRef b3BvhInfo expand(@Const @ByRef(nullValue = "b3BvhInfo()") b3BvhInfo fillValue); + public native @ByRef b3BvhInfo expand(); + + public native void push_back(@Const @ByRef b3BvhInfo _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3BvhInfoArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java new file mode 100644 index 00000000000..535006b982e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3BvhInfoOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BvhInfoOCLArray(Pointer p) { super(p); } + + public b3BvhInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3BvhInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3BvhInfo _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3BvhInfo _Val); + + public native @ByVal b3BvhInfo forcedAt(@Cast("size_t") long n); + + public native @ByVal b3BvhInfo at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3BvhInfoArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3BvhInfoArray srcArray); + + public native void copyFromHostPointer(@Const b3BvhInfo src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3BvhInfo src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3BvhInfoArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3BvhInfoArray destArray); + + public native void copyToHostPointer(b3BvhInfo destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3BvhInfo destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3BvhInfoOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java new file mode 100644 index 00000000000..b933b2750d1 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**b3BvhSubtreeInfo provides info to gather a subtree of limited size */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3BvhSubtreeInfo extends b3BvhSubtreeInfoData { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BvhSubtreeInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3BvhSubtreeInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3BvhSubtreeInfo position(long position) { + return (b3BvhSubtreeInfo)super.position(position); + } + @Override public b3BvhSubtreeInfo getPointer(long i) { + return new b3BvhSubtreeInfo((Pointer)this).offsetAddress(i); + } + + + public b3BvhSubtreeInfo() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void setAabbFromQuantizeNode(@Const @ByRef b3QuantizedBvhNode quantizedNode); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java new file mode 100644 index 00000000000..7f05bdfcd96 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3BvhSubtreeInfoArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BvhSubtreeInfoArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3BvhSubtreeInfoArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3BvhSubtreeInfoArray position(long position) { + return (b3BvhSubtreeInfoArray)super.position(position); + } + @Override public b3BvhSubtreeInfoArray getPointer(long i) { + return new b3BvhSubtreeInfoArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3BvhSubtreeInfoArray put(@Const @ByRef b3BvhSubtreeInfoArray other); + public b3BvhSubtreeInfoArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3BvhSubtreeInfoArray(@Const @ByRef b3BvhSubtreeInfoArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3BvhSubtreeInfoArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3BvhSubtreeInfo at(int n); + + public native @ByRef @Name("operator []") b3BvhSubtreeInfo get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3BvhSubtreeInfo()") b3BvhSubtreeInfo fillData); + public native void resize(int newsize); + public native @ByRef b3BvhSubtreeInfo expandNonInitializing(); + + public native @ByRef b3BvhSubtreeInfo expand(@Const @ByRef(nullValue = "b3BvhSubtreeInfo()") b3BvhSubtreeInfo fillValue); + public native @ByRef b3BvhSubtreeInfo expand(); + + public native void push_back(@Const @ByRef b3BvhSubtreeInfo _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3BvhSubtreeInfoArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java new file mode 100644 index 00000000000..a5372661677 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3BvhSubtreeInfoOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3BvhSubtreeInfoOCLArray(Pointer p) { super(p); } + + public b3BvhSubtreeInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3BvhSubtreeInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3BvhSubtreeInfo _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3BvhSubtreeInfo _Val); + + public native @ByVal b3BvhSubtreeInfo forcedAt(@Cast("size_t") long n); + + public native @ByVal b3BvhSubtreeInfo at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3BvhSubtreeInfoArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3BvhSubtreeInfoArray srcArray); + + public native void copyFromHostPointer(@Const b3BvhSubtreeInfo src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3BvhSubtreeInfo src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3BvhSubtreeInfoArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3BvhSubtreeInfoArray destArray); + + public native void copyToHostPointer(b3BvhSubtreeInfo destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3BvhSubtreeInfo destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3BvhSubtreeInfoOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java new file mode 100644 index 00000000000..d4a9ca5d283 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3CharIndexTripletData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3CharIndexTripletData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3CharIndexTripletData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CharIndexTripletData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3CharIndexTripletData position(long position) { + return (b3CharIndexTripletData)super.position(position); + } + @Override public b3CharIndexTripletData getPointer(long i) { + return new b3CharIndexTripletData((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned char") byte m_values(int i); public native b3CharIndexTripletData m_values(int i, byte setter); + @MemberGetter public native @Cast("unsigned char*") BytePointer m_values(); + public native @Cast("char") byte m_pad(); public native b3CharIndexTripletData m_pad(byte setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java new file mode 100644 index 00000000000..c637cdad564 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3CollidableOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CollidableOCLArray(Pointer p) { super(p); } + + public b3CollidableOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3CollidableOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3Collidable _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3Collidable _Val); + + public native @ByVal b3Collidable forcedAt(@Cast("size_t") long n); + + public native @ByVal b3Collidable at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3CollidableArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3CollidableArray srcArray); + + public native void copyFromHostPointer(@Const b3Collidable src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3Collidable src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3CollidableArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3CollidableArray destArray); + + public native void copyToHostPointer(b3Collidable destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3Collidable destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3CollidableOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java new file mode 100644 index 00000000000..e326e492734 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3CompoundOverlappingPairArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CompoundOverlappingPairArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3CompoundOverlappingPairArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3CompoundOverlappingPairArray position(long position) { + return (b3CompoundOverlappingPairArray)super.position(position); + } + @Override public b3CompoundOverlappingPairArray getPointer(long i) { + return new b3CompoundOverlappingPairArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3CompoundOverlappingPairArray put(@Const @ByRef b3CompoundOverlappingPairArray other); + public b3CompoundOverlappingPairArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3CompoundOverlappingPairArray(@Const @ByRef b3CompoundOverlappingPairArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3CompoundOverlappingPairArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3CompoundOverlappingPair at(int n); + + public native @ByRef @Name("operator []") b3CompoundOverlappingPair get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3CompoundOverlappingPair()") b3CompoundOverlappingPair fillData); + public native void resize(int newsize); + public native @ByRef b3CompoundOverlappingPair expandNonInitializing(); + + public native @ByRef b3CompoundOverlappingPair expand(@Const @ByRef(nullValue = "b3CompoundOverlappingPair()") b3CompoundOverlappingPair fillValue); + public native @ByRef b3CompoundOverlappingPair expand(); + + public native void push_back(@Const @ByRef b3CompoundOverlappingPair _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3CompoundOverlappingPairArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java new file mode 100644 index 00000000000..6db1da0a04d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3CompoundOverlappingPairOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3CompoundOverlappingPairOCLArray(Pointer p) { super(p); } + + public b3CompoundOverlappingPairOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3CompoundOverlappingPairOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3CompoundOverlappingPair _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3CompoundOverlappingPair _Val); + + public native @ByVal b3CompoundOverlappingPair forcedAt(@Cast("size_t") long n); + + public native @ByVal b3CompoundOverlappingPair at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3CompoundOverlappingPairArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3CompoundOverlappingPairArray srcArray); + + public native void copyFromHostPointer(@Const b3CompoundOverlappingPair src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3CompoundOverlappingPair src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3CompoundOverlappingPairArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3CompoundOverlappingPairArray destArray); + + public native void copyToHostPointer(b3CompoundOverlappingPair destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3CompoundOverlappingPair destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3CompoundOverlappingPairOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java new file mode 100644 index 00000000000..df7f91e92f4 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3Contact4Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Contact4Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3Contact4Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3Contact4Array position(long position) { + return (b3Contact4Array)super.position(position); + } + @Override public b3Contact4Array getPointer(long i) { + return new b3Contact4Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3Contact4Array put(@Const @ByRef b3Contact4Array other); + public b3Contact4Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3Contact4Array(@Const @ByRef b3Contact4Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3Contact4Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3Contact4 at(int n); + + public native @ByRef @Name("operator []") b3Contact4 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3Contact4()") b3Contact4 fillData); + public native void resize(int newsize); + public native @ByRef b3Contact4 expandNonInitializing(); + + public native @ByRef b3Contact4 expand(@Const @ByRef(nullValue = "b3Contact4()") b3Contact4 fillValue); + public native @ByRef b3Contact4 expand(); + + public native void push_back(@Const @ByRef b3Contact4 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3Contact4Array otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java new file mode 100644 index 00000000000..6e64c6f5ced --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3Contact4OCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Contact4OCLArray(Pointer p) { super(p); } + + public b3Contact4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3Contact4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3Contact4 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3Contact4 _Val); + + public native @ByVal b3Contact4 forcedAt(@Cast("size_t") long n); + + public native @ByVal b3Contact4 at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3Contact4Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3Contact4Array srcArray); + + public native void copyFromHostPointer(@Const b3Contact4 src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3Contact4 src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3Contact4Array destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3Contact4Array destArray); + + public native void copyToHostPointer(b3Contact4 destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3Contact4 destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3Contact4OCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactCache.java new file mode 100644 index 00000000000..ffa7d1a0baf --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactCache.java @@ -0,0 +1,61 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**b3ContactCache is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase. + * Those contact points are created by the collision narrow phase. + * The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time. + * updates/refreshes old contact points, and throw them away if necessary (distance becomes too large) + * reduces the cache to 4 points, when more then 4 points are added, using following rules: + * the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points + * note that some pairs of objects might have more then one contact manifold. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3ContactCache extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ContactCache() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ContactCache(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ContactCache(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ContactCache position(long position) { + return (b3ContactCache)super.position(position); + } + @Override public b3ContactCache getPointer(long i) { + return new b3ContactCache((Pointer)this).offsetAddress(i); + } + + + public native int addManifoldPoint(@Const @ByRef b3Vector3 newPoint); + + /*void replaceContactPoint(const b3Vector3& newPoint,int insertIndex) + { + b3Assert(validContactDistance(newPoint)); + m_pointCache[insertIndex] = newPoint; + } + */ + + public static native @Cast("bool") boolean validContactDistance(@Const @ByRef b3Vector3 pt); + + /** calculated new worldspace coordinates and depth, and reject points that exceed the collision margin */ + public static native void refreshContactPoints(@Const @ByRef b3Transform trA, @Const @ByRef b3Transform trB, @ByRef b3Contact4Data newContactCache); + + public static native void removeContactPoint(@ByRef b3Contact4Data newContactCache, int i); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java new file mode 100644 index 00000000000..aa12e14a847 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java @@ -0,0 +1,25 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3ContactPoint extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3ContactPoint() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ContactPoint(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java new file mode 100644 index 00000000000..85db9da7863 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3ConvexPolyhedronDataOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConvexPolyhedronDataOCLArray(Pointer p) { super(p); } + + public b3ConvexPolyhedronDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3ConvexPolyhedronDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3ConvexPolyhedronData _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3ConvexPolyhedronData _Val); + + public native @ByVal b3ConvexPolyhedronData forcedAt(@Cast("size_t") long n); + + public native @ByVal b3ConvexPolyhedronData at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3ConvexPolyhedronDataArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3ConvexPolyhedronDataArray srcArray); + + public native void copyFromHostPointer(@Const b3ConvexPolyhedronData src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3ConvexPolyhedronData src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3ConvexPolyhedronDataArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3ConvexPolyhedronDataArray destArray); + + public native void copyToHostPointer(b3ConvexPolyhedronData destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3ConvexPolyhedronData destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3ConvexPolyhedronDataOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java new file mode 100644 index 00000000000..a7613b9e97b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java @@ -0,0 +1,95 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + //for placement new +// #endif //B3_USE_PLACEMENT_NEW + +/**The b3AlignedObjectArray template class uses a subset of the stl::vector interface for its methods + * It is developed to replace stl::vector to avoid portability issues, including STL alignment issues to add SIMD/SSE data */ +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3ConvexUtilityArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConvexUtilityArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConvexUtilityArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3ConvexUtilityArray position(long position) { + return (b3ConvexUtilityArray)super.position(position); + } + @Override public b3ConvexUtilityArray getPointer(long i) { + return new b3ConvexUtilityArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3ConvexUtilityArray put(@Const @ByRef b3ConvexUtilityArray other); + public b3ConvexUtilityArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3ConvexUtilityArray(@Const @ByRef b3ConvexUtilityArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3ConvexUtilityArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef b3ConvexUtility at(int n); + + public native @ByPtrRef @Name("operator []") b3ConvexUtility get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef b3ConvexUtility fillData/*=b3ConvexUtility*()*/); + public native void resize(int newsize); + public native @ByPtrRef b3ConvexUtility expandNonInitializing(); + + public native @ByPtrRef b3ConvexUtility expand(@ByPtrRef b3ConvexUtility fillValue/*=b3ConvexUtility*()*/); + public native @ByPtrRef b3ConvexUtility expand(); + + public native void push_back(@ByPtrRef b3ConvexUtility _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef b3ConvexUtility key); + + public native int findLinearSearch(@ByPtrRef b3ConvexUtility key); + + public native int findLinearSearch2(@ByPtrRef b3ConvexUtility key); + + public native void remove(@ByPtrRef b3ConvexUtility key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3ConvexUtilityArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java new file mode 100644 index 00000000000..05598b353dc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3Dispatcher extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3Dispatcher() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Dispatcher(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java new file mode 100644 index 00000000000..0c003a696f6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java @@ -0,0 +1,70 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3FillCL extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3FillCL(Pointer p) { super(p); } + + public static class b3ConstData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ConstData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConstData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConstData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ConstData position(long position) { + return (b3ConstData)super.position(position); + } + @Override public b3ConstData getPointer(long i) { + return new b3ConstData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Int4 m_data(); public native b3ConstData m_data(b3Int4 setter); + public native @ByRef b3UnsignedInt4 m_UnsignedData(); public native b3ConstData m_UnsignedData(b3UnsignedInt4 setter); + public native int m_offset(); public native b3ConstData m_offset(int setter); + public native int m_n(); public native b3ConstData m_n(int setter); + public native int m_padding(int i); public native b3ConstData m_padding(int i, int setter); + @MemberGetter public native IntPointer m_padding(); + } + public b3FillCL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, device, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + + public native void execute(@ByRef b3UnsignedIntOCLArray src, @Cast("const unsigned int") int value, int n, int offset/*=0*/); + public native void execute(@ByRef b3UnsignedIntOCLArray src, @Cast("const unsigned int") int value, int n); + + public native void execute(@ByRef b3IntOCLArray src, int value, int n, int offset/*=0*/); + public native void execute(@ByRef b3IntOCLArray src, int value, int n); + + public native void execute(@ByRef b3FloatOCLArray src, float value, int n, int offset/*=0*/); + public native void execute(@ByRef b3FloatOCLArray src, float value, int n); + + public native void execute(@ByRef b3Int2OCLArray src, @Const @ByRef b3Int2 value, int n, int offset/*=0*/); + public native void execute(@ByRef b3Int2OCLArray src, @Const @ByRef b3Int2 value, int n); + + public native void executeHost(@ByRef b3Int2Array src, @Const @ByRef b3Int2 value, int n, int offset); + + public native void executeHost(@ByRef b3IntArray src, int value, int n, int offset); + + // void execute(b3OpenCLArray& src, const b3Int4& value, int n, int offset = 0); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java new file mode 100644 index 00000000000..ac809b2bd55 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java @@ -0,0 +1,84 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3FloatOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3FloatOCLArray(Pointer p) { super(p); } + + public b3FloatOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3FloatOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(float _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(float _Val); + + public native float forcedAt(@Cast("size_t") long n); + + public native float at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3FloatArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3FloatArray srcArray); + + public native void copyFromHostPointer(@Const FloatPointer src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const FloatPointer src, @Cast("size_t") long numElems); + public native void copyFromHostPointer(@Const FloatBuffer src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const FloatBuffer src, @Cast("size_t") long numElems); + public native void copyFromHostPointer(@Const float[] src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const float[] src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3FloatArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3FloatArray destArray); + + public native void copyToHostPointer(FloatPointer destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(FloatPointer destPtr, @Cast("size_t") long numElem); + public native void copyToHostPointer(FloatBuffer destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(FloatBuffer destPtr, @Cast("size_t") long numElem); + public native void copyToHostPointer(float[] destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(float[] destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3FloatOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java new file mode 100644 index 00000000000..de6030f5c5d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java @@ -0,0 +1,92 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**btGjkEpaSolver contributed under zlib by Nathanael Presson */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GjkEpaSolver2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GjkEpaSolver2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GjkEpaSolver2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GjkEpaSolver2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GjkEpaSolver2 position(long position) { + return (b3GjkEpaSolver2)super.position(position); + } + @Override public b3GjkEpaSolver2 getPointer(long i) { + return new b3GjkEpaSolver2((Pointer)this).offsetAddress(i); + } + + public static class sResults extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public sResults() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public sResults(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public sResults(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public sResults position(long position) { + return (sResults)super.position(position); + } + @Override public sResults getPointer(long i) { + return new sResults((Pointer)this).offsetAddress(i); + } + + /** enum b3GjkEpaSolver2::sResults::eStatus */ + public static final int + Separated = 0, /* Shapes doesnt penetrate */ + Penetrating = 1, /* Shapes are penetrating */ + GJK_Failed = 2, /* GJK phase fail, no big issue, shapes are probably just 'touching' */ + EPA_Failed = 3; /* EPA phase fail, bigger problem, need to save parameters, and debug */ + public native @ByRef b3Vector3 witnesses(int i); public native sResults witnesses(int i, b3Vector3 setter); + @MemberGetter public native b3Vector3 witnesses(); + public native @ByRef b3Vector3 normal(); public native sResults normal(b3Vector3 setter); + public native @Cast("b3Scalar") float distance(); public native sResults distance(float setter); + } + + public static native int StackSizeRequirement(); + + public static native @Cast("bool") boolean Distance(@Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB, + @Const b3ConvexPolyhedronData hullA, @Const b3ConvexPolyhedronData hullB, + @Const @ByRef b3Vector3Array verticesA, + @Const @ByRef b3Vector3Array verticesB, + @Const @ByRef b3Vector3 guess, + @ByRef sResults results); + + public static native @Cast("bool") boolean Penetration(@Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB, + @Const b3ConvexPolyhedronData hullA, @Const b3ConvexPolyhedronData hullB, + @Const @ByRef b3Vector3Array verticesA, + @Const @ByRef b3Vector3Array verticesB, + @Const @ByRef b3Vector3 guess, + @ByRef sResults results, + @Cast("bool") boolean usemargins/*=true*/); + public static native @Cast("bool") boolean Penetration(@Const @ByRef b3Transform transA, @Const @ByRef b3Transform transB, + @Const b3ConvexPolyhedronData hullA, @Const b3ConvexPolyhedronData hullB, + @Const @ByRef b3Vector3Array verticesA, + @Const @ByRef b3Vector3Array verticesB, + @Const @ByRef b3Vector3 guess, + @ByRef sResults results); +// #if 0 +// #endif +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java new file mode 100644 index 00000000000..8ffac19a80e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GjkPairDetector extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3GjkPairDetector() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GjkPairDetector(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java new file mode 100644 index 00000000000..66c5d8a3a04 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuBroadphaseInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuBroadphaseInterface(Pointer p) { super(p); } + + + public native void createProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); + public native void createLargeProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); + + public native void calculateOverlappingPairs(int maxPairs); + public native void calculateOverlappingPairsHost(int maxPairs); + + //call writeAabbsToGpu after done making all changes (createProxy etc) + public native void writeAabbsToGpu(); + + public native @ByVal cl_mem getAabbBufferWS(); + public native int getNumOverlap(); + public native @ByVal cl_mem getOverlappingPairBuffer(); + + public native @ByRef b3SapAabbOCLArray getAllAabbsGPU(); + public native @ByRef b3SapAabbArray getAllAabbsCPU(); + + public native @ByRef b3Int4OCLArray getOverlappingPairsGPU(); + public native @ByRef b3IntOCLArray getSmallAabbIndicesGPU(); + public native @ByRef b3IntOCLArray getLargeAabbIndicesGPU(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java new file mode 100644 index 00000000000..c4de65714c8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuChildShapeOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuChildShapeOCLArray(Pointer p) { super(p); } + + public b3GpuChildShapeOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3GpuChildShapeOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuChildShape _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuChildShape _Val); + + public native @ByVal b3GpuChildShape forcedAt(@Cast("size_t") long n); + + public native @ByVal b3GpuChildShape at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3GpuChildShapeArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3GpuChildShapeArray srcArray); + + public native void copyFromHostPointer(@Const b3GpuChildShape src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3GpuChildShape src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3GpuChildShapeArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3GpuChildShapeArray destArray); + + public native void copyToHostPointer(b3GpuChildShape destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3GpuChildShape destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3GpuChildShapeOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java new file mode 100644 index 00000000000..6b2ee80997b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuConstraint4 extends b3ContactConstraint4 { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuConstraint4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuConstraint4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuConstraint4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuConstraint4 position(long position) { + return (b3GpuConstraint4)super.position(position); + } + @Override public b3GpuConstraint4 getPointer(long i) { + return new b3GpuConstraint4((Pointer)this).offsetAddress(i); + } + + + public native void setFrictionCoeff(float value); + public native float getFrictionCoeff(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java new file mode 100644 index 00000000000..873335b0203 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuConstraint4Array extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuConstraint4Array(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuConstraint4Array(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3GpuConstraint4Array position(long position) { + return (b3GpuConstraint4Array)super.position(position); + } + @Override public b3GpuConstraint4Array getPointer(long i) { + return new b3GpuConstraint4Array((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3GpuConstraint4Array put(@Const @ByRef b3GpuConstraint4Array other); + public b3GpuConstraint4Array() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3GpuConstraint4Array(@Const @ByRef b3GpuConstraint4Array otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3GpuConstraint4Array otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3GpuConstraint4 at(int n); + + public native @ByRef @Name("operator []") b3GpuConstraint4 get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3GpuConstraint4()") b3GpuConstraint4 fillData); + public native void resize(int newsize); + public native @ByRef b3GpuConstraint4 expandNonInitializing(); + + public native @ByRef b3GpuConstraint4 expand(@Const @ByRef(nullValue = "b3GpuConstraint4()") b3GpuConstraint4 fillValue); + public native @ByRef b3GpuConstraint4 expand(); + + public native void push_back(@Const @ByRef b3GpuConstraint4 _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3GpuConstraint4Array otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java new file mode 100644 index 00000000000..687a72e4771 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuConstraint4OCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuConstraint4OCLArray(Pointer p) { super(p); } + + public b3GpuConstraint4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3GpuConstraint4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuConstraint4 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuConstraint4 _Val); + + public native @ByVal b3GpuConstraint4 forcedAt(@Cast("size_t") long n); + + public native @ByVal b3GpuConstraint4 at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3GpuConstraint4Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3GpuConstraint4Array srcArray); + + public native void copyFromHostPointer(@Const b3GpuConstraint4 src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3GpuConstraint4 src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3GpuConstraint4Array destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3GpuConstraint4Array destArray); + + public native void copyToHostPointer(b3GpuConstraint4 destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3GpuConstraint4 destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3GpuConstraint4OCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java new file mode 100644 index 00000000000..f50a69712fa --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java @@ -0,0 +1,75 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuConstraintInfo2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuConstraintInfo2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuConstraintInfo2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuConstraintInfo2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuConstraintInfo2 position(long position) { + return (b3GpuConstraintInfo2)super.position(position); + } + @Override public b3GpuConstraintInfo2 getPointer(long i) { + return new b3GpuConstraintInfo2((Pointer)this).offsetAddress(i); + } + + // integrator parameters: frames per second (1/stepsize), default error + // reduction parameter (0..1). + public native @Cast("b3Scalar") float fps(); public native b3GpuConstraintInfo2 fps(float setter); + public native @Cast("b3Scalar") float erp(); public native b3GpuConstraintInfo2 erp(float setter); + + // for the first and second body, pointers to two (linear and angular) + // n*3 jacobian sub matrices, stored by rows. these matrices will have + // been initialized to 0 on entry. if the second body is zero then the + // J2xx pointers may be 0. + public native @Cast("b3Scalar*") FloatPointer m_J1linearAxis(); public native b3GpuConstraintInfo2 m_J1linearAxis(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer m_J1angularAxis(); public native b3GpuConstraintInfo2 m_J1angularAxis(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer m_J2linearAxis(); public native b3GpuConstraintInfo2 m_J2linearAxis(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer m_J2angularAxis(); public native b3GpuConstraintInfo2 m_J2angularAxis(FloatPointer setter); + + // elements to jump from one row to the next in J's + public native int rowskip(); public native b3GpuConstraintInfo2 rowskip(int setter); + + // right hand sides of the equation J*v = c + cfm * lambda. cfm is the + // "constraint force mixing" vector. c is set to zero on entry, cfm is + // set to a constant value (typically very small or zero) value on entry. + public native @Cast("b3Scalar*") FloatPointer m_constraintError(); public native b3GpuConstraintInfo2 m_constraintError(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer cfm(); public native b3GpuConstraintInfo2 cfm(FloatPointer setter); + + // lo and hi limits for variables (set to -/+ infinity on entry). + public native @Cast("b3Scalar*") FloatPointer m_lowerLimit(); public native b3GpuConstraintInfo2 m_lowerLimit(FloatPointer setter); + public native @Cast("b3Scalar*") FloatPointer m_upperLimit(); public native b3GpuConstraintInfo2 m_upperLimit(FloatPointer setter); + + // findex vector for variables. see the LCP solver interface for a + // description of what this does. this is set to -1 on entry. + // note that the returned indexes are relative to the first index of + // the constraint. + public native IntPointer findex(); public native b3GpuConstraintInfo2 findex(IntPointer setter); + // number of solver iterations + public native int m_numIterations(); public native b3GpuConstraintInfo2 m_numIterations(int setter); + + //damping of the velocity + public native @Cast("b3Scalar") float m_damping(); public native b3GpuConstraintInfo2 m_damping(float setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java new file mode 100644 index 00000000000..c1e2b32d398 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuFaceOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuFaceOCLArray(Pointer p) { super(p); } + + public b3GpuFaceOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3GpuFaceOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuFace _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuFace _Val); + + public native @ByVal b3GpuFace forcedAt(@Cast("size_t") long n); + + public native @ByVal b3GpuFace at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3GpuFaceArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3GpuFaceArray srcArray); + + public native void copyFromHostPointer(@Const b3GpuFace src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3GpuFace src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3GpuFaceArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3GpuFaceArray destArray); + + public native void copyToHostPointer(b3GpuFace destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3GpuFace destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3GpuFaceOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java new file mode 100644 index 00000000000..4c39352fd3b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java @@ -0,0 +1,70 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuGenericConstraint extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuGenericConstraint() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuGenericConstraint(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuGenericConstraint(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuGenericConstraint position(long position) { + return (b3GpuGenericConstraint)super.position(position); + } + @Override public b3GpuGenericConstraint getPointer(long i) { + return new b3GpuGenericConstraint((Pointer)this).offsetAddress(i); + } + + public native int m_constraintType(); public native b3GpuGenericConstraint m_constraintType(int setter); + public native int m_rbA(); public native b3GpuGenericConstraint m_rbA(int setter); + public native int m_rbB(); public native b3GpuGenericConstraint m_rbB(int setter); + public native float m_breakingImpulseThreshold(); public native b3GpuGenericConstraint m_breakingImpulseThreshold(float setter); + + public native @ByRef b3Vector3 m_pivotInA(); public native b3GpuGenericConstraint m_pivotInA(b3Vector3 setter); + public native @ByRef b3Vector3 m_pivotInB(); public native b3GpuGenericConstraint m_pivotInB(b3Vector3 setter); + public native @ByRef b3Quaternion m_relTargetAB(); public native b3GpuGenericConstraint m_relTargetAB(b3Quaternion setter); + + public native int m_flags(); public native b3GpuGenericConstraint m_flags(int setter); + public native int m_uid(); public native b3GpuGenericConstraint m_uid(int setter); + public native int m_padding(int i); public native b3GpuGenericConstraint m_padding(int i, int setter); + @MemberGetter public native IntPointer m_padding(); + + public native int getRigidBodyA(); + public native int getRigidBodyB(); + + public native @Const @ByRef b3Vector3 getPivotInA(); + + public native @Const @ByRef b3Vector3 getPivotInB(); + + public native int isEnabled(); + + public native float getBreakingImpulseThreshold(); + + /**internal method used by the constraint solver, don't use them directly */ + public native void getInfo1(@Cast("unsigned int*") IntPointer info, @Const b3RigidBodyData bodies); + public native void getInfo1(@Cast("unsigned int*") IntBuffer info, @Const b3RigidBodyData bodies); + public native void getInfo1(@Cast("unsigned int*") int[] info, @Const b3RigidBodyData bodies); + + /**internal method used by the constraint solver, don't use them directly */ + public native void getInfo2(b3GpuConstraintInfo2 info, @Const b3RigidBodyData bodies); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java new file mode 100644 index 00000000000..f6ad175ab5a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuGenericConstraintArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuGenericConstraintArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuGenericConstraintArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3GpuGenericConstraintArray position(long position) { + return (b3GpuGenericConstraintArray)super.position(position); + } + @Override public b3GpuGenericConstraintArray getPointer(long i) { + return new b3GpuGenericConstraintArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3GpuGenericConstraintArray put(@Const @ByRef b3GpuGenericConstraintArray other); + public b3GpuGenericConstraintArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3GpuGenericConstraintArray(@Const @ByRef b3GpuGenericConstraintArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3GpuGenericConstraintArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3GpuGenericConstraint at(int n); + + public native @ByRef @Name("operator []") b3GpuGenericConstraint get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3GpuGenericConstraint()") b3GpuGenericConstraint fillData); + public native void resize(int newsize); + public native @ByRef b3GpuGenericConstraint expandNonInitializing(); + + public native @ByRef b3GpuGenericConstraint expand(@Const @ByRef(nullValue = "b3GpuGenericConstraint()") b3GpuGenericConstraint fillValue); + public native @ByRef b3GpuGenericConstraint expand(); + + public native void push_back(@Const @ByRef b3GpuGenericConstraint _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3GpuGenericConstraintArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java new file mode 100644 index 00000000000..14790e93390 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuGenericConstraintOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuGenericConstraintOCLArray(Pointer p) { super(p); } + + public b3GpuGenericConstraintOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3GpuGenericConstraintOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuGenericConstraint _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuGenericConstraint _Val); + + public native @ByVal b3GpuGenericConstraint forcedAt(@Cast("size_t") long n); + + public native @ByVal b3GpuGenericConstraint at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3GpuGenericConstraintArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3GpuGenericConstraintArray srcArray); + + public native void copyFromHostPointer(@Const b3GpuGenericConstraint src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3GpuGenericConstraint src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3GpuGenericConstraintArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3GpuGenericConstraintArray destArray); + + public native void copyToHostPointer(b3GpuGenericConstraint destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3GpuGenericConstraint destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3GpuGenericConstraintOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java new file mode 100644 index 00000000000..6cb804b3a50 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuGridBroadphase extends b3GpuBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuGridBroadphase(Pointer p) { super(p); } + + public b3GpuGridBroadphase(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q) { super((Pointer)null); allocate(ctx, device, q); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + + public static native b3GpuBroadphaseInterface CreateFunc(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + + public native void createProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); + public native void createLargeProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); + + public native void calculateOverlappingPairs(int maxPairs); + public native void calculateOverlappingPairsHost(int maxPairs); + + //call writeAabbsToGpu after done making all changes (createProxy etc) + public native void writeAabbsToGpu(); + + public native @ByVal cl_mem getAabbBufferWS(); + public native int getNumOverlap(); + public native @ByVal cl_mem getOverlappingPairBuffer(); + + public native @ByRef b3SapAabbOCLArray getAllAabbsGPU(); + public native @ByRef b3SapAabbArray getAllAabbsCPU(); + + public native @ByRef b3Int4OCLArray getOverlappingPairsGPU(); + public native @ByRef b3IntOCLArray getSmallAabbIndicesGPU(); + public native @ByRef b3IntOCLArray getLargeAabbIndicesGPU(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java new file mode 100644 index 00000000000..90d5fef71b3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuJacobiContactSolver extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuJacobiContactSolver(Pointer p) { super(p); } + + public b3GpuJacobiContactSolver(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int pairCapacity) { super((Pointer)null); allocate(ctx, device, queue, pairCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int pairCapacity); + + public native void solveContacts(int numBodies, @ByVal cl_mem bodyBuf, @ByVal cl_mem inertiaBuf, int numContacts, @ByVal cl_mem contactBuf, @Const @ByRef b3Config config, int static0Index); + public native void solveGroupHost(b3RigidBodyData bodies, b3InertiaData inertias, int numBodies, b3Contact4 manifoldPtr, int numManifolds, @Const @ByRef b3JacobiSolverInfo solverInfo); + //void solveGroupHost(btRigidBodyCL* bodies,b3InertiaData* inertias,int numBodies,btContact4* manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btJacobiSolverInfo& solverInfo); + + //b3Scalar solveGroup(b3OpenCLArray* gpuBodies,b3OpenCLArray* gpuInertias, int numBodies,b3OpenCLArray* gpuConstraints,int numConstraints,const b3ContactSolverInfo& infoGlobal); + + //void solveGroup(btOpenCLArray* bodies,btOpenCLArray* inertias,btOpenCLArray* manifoldPtr,const btJacobiSolverInfo& solverInfo); + //void solveGroupMixed(btOpenCLArray* bodies,btOpenCLArray* inertias,btOpenCLArray* manifoldPtr,const btJacobiSolverInfo& solverInfo); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java new file mode 100644 index 00000000000..c17df9e2a3d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java @@ -0,0 +1,101 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuNarrowPhase extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuNarrowPhase(Pointer p) { super(p); } + + public b3GpuNarrowPhase(@ByVal cl_context vtx, @ByVal cl_device_id dev, @ByVal cl_command_queue q, @Const @ByRef b3Config config) { super((Pointer)null); allocate(vtx, dev, q, config); } + private native void allocate(@ByVal cl_context vtx, @ByVal cl_device_id dev, @ByVal cl_command_queue q, @Const @ByRef b3Config config); + + public native int registerSphereShape(float radius); + public native int registerPlaneShape(@Const @ByRef b3Vector3 planeNormal, float planeConstant); + + public native int registerCompoundShape(b3GpuChildShapeArray childShapes); + public native int registerFace(@Const @ByRef b3Vector3 faceNormal, float faceConstant); + + public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const FloatPointer scaling); + public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const FloatBuffer scaling); + public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const float[] scaling); + + //do they need to be merged? + + public native int registerConvexHullShape(b3ConvexUtility utilPtr); + public native int registerConvexHullShape(@Const FloatPointer vertices, int strideInBytes, int numVertices, @Const FloatPointer scaling); + public native int registerConvexHullShape(@Const FloatBuffer vertices, int strideInBytes, int numVertices, @Const FloatBuffer scaling); + public native int registerConvexHullShape(@Const float[] vertices, int strideInBytes, int numVertices, @Const float[] scaling); + + public native int registerRigidBody(int collidableIndex, float mass, @Const FloatPointer _position, @Const FloatPointer orientation, @Const FloatPointer aabbMin, @Const FloatPointer aabbMax, @Cast("bool") boolean writeToGpu); + public native int registerRigidBody(int collidableIndex, float mass, @Const FloatBuffer _position, @Const FloatBuffer orientation, @Const FloatBuffer aabbMin, @Const FloatBuffer aabbMax, @Cast("bool") boolean writeToGpu); + public native int registerRigidBody(int collidableIndex, float mass, @Const float[] _position, @Const float[] orientation, @Const float[] aabbMin, @Const float[] aabbMax, @Cast("bool") boolean writeToGpu); + public native void setObjectTransform(@Const FloatPointer _position, @Const FloatPointer orientation, int bodyIndex); + public native void setObjectTransform(@Const FloatBuffer _position, @Const FloatBuffer orientation, int bodyIndex); + public native void setObjectTransform(@Const float[] _position, @Const float[] orientation, int bodyIndex); + + public native void writeAllBodiesToGpu(); + public native void reset(); + public native void readbackAllBodiesToCpu(); + public native @Cast("bool") boolean getObjectTransformFromCpu(FloatPointer _position, FloatPointer orientation, int bodyIndex); + public native @Cast("bool") boolean getObjectTransformFromCpu(FloatBuffer _position, FloatBuffer orientation, int bodyIndex); + public native @Cast("bool") boolean getObjectTransformFromCpu(float[] _position, float[] orientation, int bodyIndex); + + public native void setObjectTransformCpu(FloatPointer _position, FloatPointer orientation, int bodyIndex); + public native void setObjectTransformCpu(FloatBuffer _position, FloatBuffer orientation, int bodyIndex); + public native void setObjectTransformCpu(float[] _position, float[] orientation, int bodyIndex); + public native void setObjectVelocityCpu(FloatPointer linVel, FloatPointer angVel, int bodyIndex); + public native void setObjectVelocityCpu(FloatBuffer linVel, FloatBuffer angVel, int bodyIndex); + public native void setObjectVelocityCpu(float[] linVel, float[] angVel, int bodyIndex); + + public native void computeContacts(@ByVal cl_mem broadphasePairs, int numBroadphasePairs, @ByVal cl_mem aabbsWorldSpace, int numObjects); + + public native @ByVal cl_mem getBodiesGpu(); + public native @Const b3RigidBodyData getBodiesCpu(); + //struct b3RigidBodyData* getBodiesCpu(); + + public native int getNumBodiesGpu(); + + public native @ByVal cl_mem getBodyInertiasGpu(); + public native int getNumBodyInertiasGpu(); + + public native @ByVal cl_mem getCollidablesGpu(); + public native @Const b3Collidable getCollidablesCpu(); + public native int getNumCollidablesGpu(); + + public native @Const b3SapAabb getLocalSpaceAabbsCpu(); + + public native @Const b3Contact4 getContactsCPU(); + + public native @ByVal cl_mem getContactsGpu(); + public native int getNumContactsGpu(); + + public native @ByVal cl_mem getAabbLocalSpaceBufferGpu(); + + public native int getNumRigidBodies(); + + public native int allocateCollidable(); + + public native int getStatic0Index(); + public native @ByRef b3Collidable getCollidableCpu(int collidableIndex); + + public native b3GpuNarrowPhaseInternalData getInternalData(); + + public native @Const @ByRef b3SapAabb getLocalSpaceAabb(int collidableIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java new file mode 100644 index 00000000000..ba02eb17354 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java @@ -0,0 +1,99 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuNarrowPhaseInternalData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuNarrowPhaseInternalData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuNarrowPhaseInternalData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuNarrowPhaseInternalData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuNarrowPhaseInternalData position(long position) { + return (b3GpuNarrowPhaseInternalData)super.position(position); + } + @Override public b3GpuNarrowPhaseInternalData getPointer(long i) { + return new b3GpuNarrowPhaseInternalData((Pointer)this).offsetAddress(i); + } + + public native b3ConvexUtilityArray m_convexData(); public native b3GpuNarrowPhaseInternalData m_convexData(b3ConvexUtilityArray setter); + + public native @ByRef b3ConvexPolyhedronDataArray m_convexPolyhedra(); public native b3GpuNarrowPhaseInternalData m_convexPolyhedra(b3ConvexPolyhedronDataArray setter); + public native @ByRef b3Vector3Array m_uniqueEdges(); public native b3GpuNarrowPhaseInternalData m_uniqueEdges(b3Vector3Array setter); + public native @ByRef b3Vector3Array m_convexVertices(); public native b3GpuNarrowPhaseInternalData m_convexVertices(b3Vector3Array setter); + public native @ByRef b3IntArray m_convexIndices(); public native b3GpuNarrowPhaseInternalData m_convexIndices(b3IntArray setter); + + public native b3ConvexPolyhedronDataOCLArray m_convexPolyhedraGPU(); public native b3GpuNarrowPhaseInternalData m_convexPolyhedraGPU(b3ConvexPolyhedronDataOCLArray setter); + public native b3Vector3OCLArray m_uniqueEdgesGPU(); public native b3GpuNarrowPhaseInternalData m_uniqueEdgesGPU(b3Vector3OCLArray setter); + public native b3Vector3OCLArray m_convexVerticesGPU(); public native b3GpuNarrowPhaseInternalData m_convexVerticesGPU(b3Vector3OCLArray setter); + public native b3IntOCLArray m_convexIndicesGPU(); public native b3GpuNarrowPhaseInternalData m_convexIndicesGPU(b3IntOCLArray setter); + + public native b3Vector3OCLArray m_worldVertsB1GPU(); public native b3GpuNarrowPhaseInternalData m_worldVertsB1GPU(b3Vector3OCLArray setter); + public native b3Int4OCLArray m_clippingFacesOutGPU(); public native b3GpuNarrowPhaseInternalData m_clippingFacesOutGPU(b3Int4OCLArray setter); + public native b3Vector3OCLArray m_worldNormalsAGPU(); public native b3GpuNarrowPhaseInternalData m_worldNormalsAGPU(b3Vector3OCLArray setter); + public native b3Vector3OCLArray m_worldVertsA1GPU(); public native b3GpuNarrowPhaseInternalData m_worldVertsA1GPU(b3Vector3OCLArray setter); + public native b3Vector3OCLArray m_worldVertsB2GPU(); public native b3GpuNarrowPhaseInternalData m_worldVertsB2GPU(b3Vector3OCLArray setter); + + public native @ByRef b3GpuChildShapeArray m_cpuChildShapes(); public native b3GpuNarrowPhaseInternalData m_cpuChildShapes(b3GpuChildShapeArray setter); + public native b3GpuChildShapeOCLArray m_gpuChildShapes(); public native b3GpuNarrowPhaseInternalData m_gpuChildShapes(b3GpuChildShapeOCLArray setter); + + public native @ByRef b3GpuFaceArray m_convexFaces(); public native b3GpuNarrowPhaseInternalData m_convexFaces(b3GpuFaceArray setter); + public native b3GpuFaceOCLArray m_convexFacesGPU(); public native b3GpuNarrowPhaseInternalData m_convexFacesGPU(b3GpuFaceOCLArray setter); + + public native GpuSatCollision m_gpuSatCollision(); public native b3GpuNarrowPhaseInternalData m_gpuSatCollision(GpuSatCollision setter); + + public native b3Int4OCLArray m_triangleConvexPairs(); public native b3GpuNarrowPhaseInternalData m_triangleConvexPairs(b3Int4OCLArray setter); + + public native b3Contact4OCLArray m_pBufContactBuffersGPU(int i); public native b3GpuNarrowPhaseInternalData m_pBufContactBuffersGPU(int i, b3Contact4OCLArray setter); + @MemberGetter public native @Cast("b3OpenCLArray**") PointerPointer m_pBufContactBuffersGPU(); + public native int m_currentContactBuffer(); public native b3GpuNarrowPhaseInternalData m_currentContactBuffer(int setter); + public native b3Contact4Array m_pBufContactOutCPU(); public native b3GpuNarrowPhaseInternalData m_pBufContactOutCPU(b3Contact4Array setter); + + public native b3RigidBodyDataArray m_bodyBufferCPU(); public native b3GpuNarrowPhaseInternalData m_bodyBufferCPU(b3RigidBodyDataArray setter); + public native b3RigidBodyDataOCLArray m_bodyBufferGPU(); public native b3GpuNarrowPhaseInternalData m_bodyBufferGPU(b3RigidBodyDataOCLArray setter); + + public native b3InertiaDataArray m_inertiaBufferCPU(); public native b3GpuNarrowPhaseInternalData m_inertiaBufferCPU(b3InertiaDataArray setter); + public native b3InertiaDataOCLArray m_inertiaBufferGPU(); public native b3GpuNarrowPhaseInternalData m_inertiaBufferGPU(b3InertiaDataOCLArray setter); + + public native int m_numAcceleratedShapes(); public native b3GpuNarrowPhaseInternalData m_numAcceleratedShapes(int setter); + public native int m_numAcceleratedRigidBodies(); public native b3GpuNarrowPhaseInternalData m_numAcceleratedRigidBodies(int setter); + + public native @ByRef b3CollidableArray m_collidablesCPU(); public native b3GpuNarrowPhaseInternalData m_collidablesCPU(b3CollidableArray setter); + public native b3CollidableOCLArray m_collidablesGPU(); public native b3GpuNarrowPhaseInternalData m_collidablesGPU(b3CollidableOCLArray setter); + + public native b3SapAabbOCLArray m_localShapeAABBGPU(); public native b3GpuNarrowPhaseInternalData m_localShapeAABBGPU(b3SapAabbOCLArray setter); + public native b3SapAabbArray m_localShapeAABBCPU(); public native b3GpuNarrowPhaseInternalData m_localShapeAABBCPU(b3SapAabbArray setter); + + public native @ByRef b3OptimizedBvhArray m_bvhData(); public native b3GpuNarrowPhaseInternalData m_bvhData(b3OptimizedBvhArray setter); + public native @ByRef b3TriangleIndexVertexArrayArray m_meshInterfaces(); public native b3GpuNarrowPhaseInternalData m_meshInterfaces(b3TriangleIndexVertexArrayArray setter); + + public native @ByRef b3QuantizedBvhNodeArray m_treeNodesCPU(); public native b3GpuNarrowPhaseInternalData m_treeNodesCPU(b3QuantizedBvhNodeArray setter); + public native @ByRef b3BvhSubtreeInfoArray m_subTreesCPU(); public native b3GpuNarrowPhaseInternalData m_subTreesCPU(b3BvhSubtreeInfoArray setter); + + public native @ByRef b3BvhInfoArray m_bvhInfoCPU(); public native b3GpuNarrowPhaseInternalData m_bvhInfoCPU(b3BvhInfoArray setter); + public native b3BvhInfoOCLArray m_bvhInfoGPU(); public native b3GpuNarrowPhaseInternalData m_bvhInfoGPU(b3BvhInfoOCLArray setter); + + public native b3QuantizedBvhNodeOCLArray m_treeNodesGPU(); public native b3GpuNarrowPhaseInternalData m_treeNodesGPU(b3QuantizedBvhNodeOCLArray setter); + public native b3BvhSubtreeInfoOCLArray m_subTreesGPU(); public native b3GpuNarrowPhaseInternalData m_subTreesGPU(b3BvhSubtreeInfoOCLArray setter); + + public native @ByRef b3Config m_config(); public native b3GpuNarrowPhaseInternalData m_config(b3Config setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java new file mode 100644 index 00000000000..246038becff --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java @@ -0,0 +1,62 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**\brief GPU Parallel Linearized Bounding Volume Heirarchy(LBVH) that is reconstructed every frame + * \remarks + * See presentation in docs/b3GpuParallelLinearBvh.pdf for algorithm details. + * \par + * Related papers: \n + * "Fast BVH Construction on GPUs" [Lauterbach et al. 2009] \n + * "Maximizing Parallelism in the Construction of BVHs, Octrees, and k-d trees" [Karras 2012] \n + * \par + * The basic algorithm for building the BVH as presented in [Lauterbach et al. 2009] consists of 4 stages: + * - [fully parallel] Assign morton codes for each AABB using its center (after quantizing the AABB centers into a virtual grid) + * - [fully parallel] Sort morton codes + * - [somewhat parallel] Build binary radix tree (assign parent/child pointers for internal nodes of the BVH) + * - [somewhat parallel] Set internal node AABBs + * \par + * [Karras 2012] improves on the algorithm by introducing fully parallel methods for the last 2 stages. + * The BVH implementation here shares many concepts with [Karras 2012], but a different method is used for constructing the tree. + * Instead of searching for the child nodes of each internal node, we search for the parent node of each node. + * Additionally, a non-atomic traversal that starts from the leaf nodes and moves towards the root node is used to set the AABBs. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuParallelLinearBvh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuParallelLinearBvh(Pointer p) { super(p); } + + public b3GpuParallelLinearBvh(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(context, device, queue); } + private native void allocate(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + + /**Must be called before any other function */ + public native void build(@Const @ByRef b3SapAabbOCLArray worldSpaceAabbs, @Const @ByRef b3IntOCLArray smallAabbIndices, + @Const @ByRef b3IntOCLArray largeAabbIndices); + + /**calculateOverlappingPairs() uses the worldSpaceAabbs parameter of b3GpuParallelLinearBvh::build() as the query AABBs. + * @param out_overlappingPairs The size() of this array is used to determine the max number of pairs. + * If the number of overlapping pairs is < out_overlappingPairs.size(), out_overlappingPairs is resized. */ + public native void calculateOverlappingPairs(@ByRef b3Int4OCLArray out_overlappingPairs); + + /**@param out_numRigidRayPairs Array of length 1; contains the number of detected ray-rigid AABB intersections; + * this value may be greater than out_rayRigidPairs.size() if out_rayRigidPairs is not large enough. + * @param out_rayRigidPairs Contains an array of rays intersecting rigid AABBs; x == ray index, y == rigid body index. + * If the size of this array is insufficient to hold all ray-rigid AABB intersections, additional intersections are discarded. */ + public native void testRaysAgainstBvhAabbs(@Const @ByRef b3RayInfoOCLArray rays, + @ByRef b3IntOCLArray out_numRayRigidPairs, @ByRef b3Int2OCLArray out_rayRigidPairs); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java new file mode 100644 index 00000000000..30746bd693f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuParallelLinearBvhBroadphase extends b3GpuBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuParallelLinearBvhBroadphase(Pointer p) { super(p); } + + public b3GpuParallelLinearBvhBroadphase(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(context, device, queue); } + private native void allocate(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + + public native void createProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); + public native void createLargeProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); + + public native void calculateOverlappingPairs(int maxPairs); + public native void calculateOverlappingPairsHost(int maxPairs); + + //call writeAabbsToGpu after done making all changes (createProxy etc) + public native void writeAabbsToGpu(); + + public native int getNumOverlap(); + public native @ByVal cl_mem getOverlappingPairBuffer(); + + public native @ByVal cl_mem getAabbBufferWS(); + public native @ByRef b3SapAabbOCLArray getAllAabbsGPU(); + + public native @ByRef b3Int4OCLArray getOverlappingPairsGPU(); + public native @ByRef b3IntOCLArray getSmallAabbIndicesGPU(); + public native @ByRef b3IntOCLArray getLargeAabbIndicesGPU(); + + public native @ByRef b3SapAabbArray getAllAabbsCPU(); + + public static native b3GpuBroadphaseInterface CreateFunc(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java new file mode 100644 index 00000000000..1c1902d68b8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuPgsConstraintSolver extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuPgsConstraintSolver(Pointer p) { super(p); } + + public b3GpuPgsConstraintSolver(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, @Cast("bool") boolean usePgs) { super((Pointer)null); allocate(ctx, device, queue, usePgs); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, @Cast("bool") boolean usePgs); + + public native @Cast("b3Scalar") float solveGroupCacheFriendlyIterations(b3GpuGenericConstraintOCLArray gpuConstraints1, int numConstraints, @Const @ByRef b3ContactSolverInfo infoGlobal); + public native @Cast("b3Scalar") float solveGroupCacheFriendlySetup(b3RigidBodyDataOCLArray gpuBodies, b3InertiaDataOCLArray gpuInertias, int numBodies, b3GpuGenericConstraintOCLArray gpuConstraints, int numConstraints, @Const @ByRef b3ContactSolverInfo infoGlobal); + public native @Cast("b3Scalar") float solveGroupCacheFriendlyFinish(b3RigidBodyDataOCLArray gpuBodies, b3InertiaDataOCLArray gpuInertias, int numBodies, b3GpuGenericConstraintOCLArray gpuConstraints, int numConstraints, @Const @ByRef b3ContactSolverInfo infoGlobal); + + public native @Cast("b3Scalar") float solveGroup(b3RigidBodyDataOCLArray gpuBodies, b3InertiaDataOCLArray gpuInertias, int numBodies, b3GpuGenericConstraintOCLArray gpuConstraints, int numConstraints, @Const @ByRef b3ContactSolverInfo infoGlobal); + public native void solveJoints(int numBodies, b3RigidBodyDataOCLArray gpuBodies, b3InertiaDataOCLArray gpuInertias, + int numConstraints, b3GpuGenericConstraintOCLArray gpuConstraints); + + + public native void recomputeBatches(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java new file mode 100644 index 00000000000..5831d7d4bb6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java @@ -0,0 +1,30 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuPgsContactSolver extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuPgsContactSolver(Pointer p) { super(p); } + + public b3GpuPgsContactSolver(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, int pairCapacity) { super((Pointer)null); allocate(ctx, device, q, pairCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, int pairCapacity); + + public native void solveContacts(int numBodies, @ByVal cl_mem bodyBuf, @ByVal cl_mem inertiaBuf, int numContacts, @ByVal cl_mem contactBuf, @Const @ByRef b3Config config, int static0Index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java new file mode 100644 index 00000000000..6c058ff2397 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java @@ -0,0 +1,36 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuRaycast extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuRaycast(Pointer p) { super(p); } + + public b3GpuRaycast(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q) { super((Pointer)null); allocate(ctx, device, q); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + + public native void castRaysHost(@Const @ByRef b3RayInfoArray raysIn, @ByRef b3RayHitArray hitResults, + int numBodies, @Const b3RigidBodyData bodies, int numCollidables, @Const b3Collidable collidables, + @Const b3GpuNarrowPhaseInternalData narrowphaseData); + + public native void castRays(@Const @ByRef b3RayInfoArray rays, @ByRef b3RayHitArray hitResults, + int numBodies, @Const b3RigidBodyData bodies, int numCollidables, @Const b3Collidable collidables, + @Const b3GpuNarrowPhaseInternalData narrowphaseData, b3GpuBroadphaseInterface broadphase); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java new file mode 100644 index 00000000000..ef333b93211 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java @@ -0,0 +1,69 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuRigidBodyPipeline extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuRigidBodyPipeline(Pointer p) { super(p); } + + public b3GpuRigidBodyPipeline(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, b3GpuNarrowPhase narrowphase, b3GpuBroadphaseInterface broadphaseSap, b3DynamicBvhBroadphase broadphaseDbvt, @Const @ByRef b3Config config) { super((Pointer)null); allocate(ctx, device, q, narrowphase, broadphaseSap, broadphaseDbvt, config); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, b3GpuNarrowPhase narrowphase, b3GpuBroadphaseInterface broadphaseSap, b3DynamicBvhBroadphase broadphaseDbvt, @Const @ByRef b3Config config); + + public native void stepSimulation(float deltaTime); + public native void integrate(float timeStep); + public native void setupGpuAabbsFull(); + + public native int registerConvexPolyhedron(b3ConvexUtility convex); + + //int registerConvexPolyhedron(const float* vertices, int strideInBytes, int numVertices, const float* scaling); + //int registerSphereShape(float radius); + //int registerPlaneShape(const b3Vector3& planeNormal, float planeConstant); + + //int registerConcaveMesh(b3AlignedObjectArray* vertices, b3AlignedObjectArray* indices, const float* scaling); + //int registerCompoundShape(b3AlignedObjectArray* childShapes); + + public native int registerPhysicsInstance(float mass, @Const FloatPointer _position, @Const FloatPointer orientation, int collisionShapeIndex, int userData, @Cast("bool") boolean writeInstanceToGpu); + public native int registerPhysicsInstance(float mass, @Const FloatBuffer _position, @Const FloatBuffer orientation, int collisionShapeIndex, int userData, @Cast("bool") boolean writeInstanceToGpu); + public native int registerPhysicsInstance(float mass, @Const float[] _position, @Const float[] orientation, int collisionShapeIndex, int userData, @Cast("bool") boolean writeInstanceToGpu); + //if you passed "writeInstanceToGpu" false in the registerPhysicsInstance method (for performance) you need to call writeAllInstancesToGpu after all instances are registered + public native void writeAllInstancesToGpu(); + public native void copyConstraintsToHost(); + public native void setGravity(@Const FloatPointer grav); + public native void setGravity(@Const FloatBuffer grav); + public native void setGravity(@Const float[] grav); + public native void reset(); + + public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const FloatPointer pivotInA, @Const FloatPointer pivotInB, float breakingThreshold); + public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const FloatBuffer pivotInA, @Const FloatBuffer pivotInB, float breakingThreshold); + public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const float[] pivotInA, @Const float[] pivotInB, float breakingThreshold); + public native int createFixedConstraint(int bodyA, int bodyB, @Const FloatPointer pivotInA, @Const FloatPointer pivotInB, @Const FloatPointer relTargetAB, float breakingThreshold); + public native int createFixedConstraint(int bodyA, int bodyB, @Const FloatBuffer pivotInA, @Const FloatBuffer pivotInB, @Const FloatBuffer relTargetAB, float breakingThreshold); + public native int createFixedConstraint(int bodyA, int bodyB, @Const float[] pivotInA, @Const float[] pivotInB, @Const float[] relTargetAB, float breakingThreshold); + public native void removeConstraintByUid(int uid); + + public native void addConstraint(b3TypedConstraint constraint); + public native void removeConstraint(b3TypedConstraint constraint); + + public native void castRays(@Const @ByRef b3RayInfoArray rays, @ByRef b3RayHitArray hitResults); + + public native @ByVal cl_mem getBodyBuffer(); + + public native int getNumBodies(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java new file mode 100644 index 00000000000..48b26ceb215 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java @@ -0,0 +1,70 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuRigidBodyPipelineInternalData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuRigidBodyPipelineInternalData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuRigidBodyPipelineInternalData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuRigidBodyPipelineInternalData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuRigidBodyPipelineInternalData position(long position) { + return (b3GpuRigidBodyPipelineInternalData)super.position(position); + } + @Override public b3GpuRigidBodyPipelineInternalData getPointer(long i) { + return new b3GpuRigidBodyPipelineInternalData((Pointer)this).offsetAddress(i); + } + + public native @ByRef cl_context m_context(); public native b3GpuRigidBodyPipelineInternalData m_context(cl_context setter); + public native @ByRef cl_device_id m_device(); public native b3GpuRigidBodyPipelineInternalData m_device(cl_device_id setter); + public native @ByRef cl_command_queue m_queue(); public native b3GpuRigidBodyPipelineInternalData m_queue(cl_command_queue setter); + + public native @ByRef cl_kernel m_integrateTransformsKernel(); public native b3GpuRigidBodyPipelineInternalData m_integrateTransformsKernel(cl_kernel setter); + public native @ByRef cl_kernel m_updateAabbsKernel(); public native b3GpuRigidBodyPipelineInternalData m_updateAabbsKernel(cl_kernel setter); + public native @ByRef cl_kernel m_clearOverlappingPairsKernel(); public native b3GpuRigidBodyPipelineInternalData m_clearOverlappingPairsKernel(cl_kernel setter); + + public native b3PgsJacobiSolver m_solver(); public native b3GpuRigidBodyPipelineInternalData m_solver(b3PgsJacobiSolver setter); + + public native b3GpuPgsConstraintSolver m_gpuSolver(); public native b3GpuRigidBodyPipelineInternalData m_gpuSolver(b3GpuPgsConstraintSolver setter); + + public native b3GpuPgsContactSolver m_solver2(); public native b3GpuRigidBodyPipelineInternalData m_solver2(b3GpuPgsContactSolver setter); + public native b3GpuJacobiContactSolver m_solver3(); public native b3GpuRigidBodyPipelineInternalData m_solver3(b3GpuJacobiContactSolver setter); + public native b3GpuRaycast m_raycaster(); public native b3GpuRigidBodyPipelineInternalData m_raycaster(b3GpuRaycast setter); + + public native b3GpuBroadphaseInterface m_broadphaseSap(); public native b3GpuRigidBodyPipelineInternalData m_broadphaseSap(b3GpuBroadphaseInterface setter); + + public native b3DynamicBvhBroadphase m_broadphaseDbvt(); public native b3GpuRigidBodyPipelineInternalData m_broadphaseDbvt(b3DynamicBvhBroadphase setter); + public native b3SapAabbOCLArray m_allAabbsGPU(); public native b3GpuRigidBodyPipelineInternalData m_allAabbsGPU(b3SapAabbOCLArray setter); + public native @ByRef b3SapAabbArray m_allAabbsCPU(); public native b3GpuRigidBodyPipelineInternalData m_allAabbsCPU(b3SapAabbArray setter); + public native b3Int4OCLArray m_overlappingPairsGPU(); public native b3GpuRigidBodyPipelineInternalData m_overlappingPairsGPU(b3Int4OCLArray setter); + + public native b3GpuGenericConstraintOCLArray m_gpuConstraints(); public native b3GpuRigidBodyPipelineInternalData m_gpuConstraints(b3GpuGenericConstraintOCLArray setter); + public native @ByRef b3GpuGenericConstraintArray m_cpuConstraints(); public native b3GpuRigidBodyPipelineInternalData m_cpuConstraints(b3GpuGenericConstraintArray setter); + + public native @ByRef b3TypedConstraintArray m_joints(); public native b3GpuRigidBodyPipelineInternalData m_joints(b3TypedConstraintArray setter); + public native int m_constraintUid(); public native b3GpuRigidBodyPipelineInternalData m_constraintUid(int setter); + public native b3GpuNarrowPhase m_narrowphase(); public native b3GpuRigidBodyPipelineInternalData m_narrowphase(b3GpuNarrowPhase setter); + public native @ByRef b3Vector3 m_gravity(); public native b3GpuRigidBodyPipelineInternalData m_gravity(b3Vector3 setter); + + public native @ByRef b3Config m_config(); public native b3GpuRigidBodyPipelineInternalData m_config(b3Config setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java new file mode 100644 index 00000000000..d3c36f5898a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java @@ -0,0 +1,94 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuSapBroadphase extends b3GpuBroadphaseInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuSapBroadphase(Pointer p) { super(p); } + + + + + public native @ByRef b3SapAabbArray m_allAabbsCPU(); public native b3GpuSapBroadphase m_allAabbsCPU(b3SapAabbArray setter); + + public native @ByRef b3SapAabbOCLArray getAllAabbsGPU(); + public native @ByRef b3SapAabbArray getAllAabbsCPU(); + + + + + + + public native @ByRef b3IntArray m_smallAabbsMappingCPU(); public native b3GpuSapBroadphase m_smallAabbsMappingCPU(b3IntArray setter); + + + public native @ByRef b3IntArray m_largeAabbsMappingCPU(); public native b3GpuSapBroadphase m_largeAabbsMappingCPU(b3IntArray setter); + + + + //temporary gpu work memory + + + + public native b3PrefixScanFloat4CL m_prefixScanFloat4(); public native b3GpuSapBroadphase m_prefixScanFloat4(b3PrefixScanFloat4CL setter); + + /** enum b3GpuSapBroadphase::b3GpuSapKernelType */ + public static final int + B3_GPU_SAP_KERNEL_BRUTE_FORCE_CPU = 1, + B3_GPU_SAP_KERNEL_BRUTE_FORCE_GPU = 2, + B3_GPU_SAP_KERNEL_ORIGINAL = 3, + B3_GPU_SAP_KERNEL_BARRIER = 4, + B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY = 5; + + public b3GpuSapBroadphase(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, @Cast("b3GpuSapBroadphase::b3GpuSapKernelType") int kernelType/*=b3GpuSapBroadphase::B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY*/) { super((Pointer)null); allocate(ctx, device, q, kernelType); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, @Cast("b3GpuSapBroadphase::b3GpuSapKernelType") int kernelType/*=b3GpuSapBroadphase::B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY*/); + public b3GpuSapBroadphase(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q) { super((Pointer)null); allocate(ctx, device, q); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + + public static native b3GpuBroadphaseInterface CreateFuncBruteForceCpu(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + + public static native b3GpuBroadphaseInterface CreateFuncBruteForceGpu(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + + public static native b3GpuBroadphaseInterface CreateFuncOriginal(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public static native b3GpuBroadphaseInterface CreateFuncBarrier(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public static native b3GpuBroadphaseInterface CreateFuncLocalMemory(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + + public native void calculateOverlappingPairs(int maxPairs); + public native void calculateOverlappingPairsHost(int maxPairs); + + public native void reset(); + + public native void init3dSap(); + public native void calculateOverlappingPairsHostIncremental3Sap(); + + public native void createProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); + public native void createLargeProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); + + //call writeAabbsToGpu after done making all changes (createProxy etc) + public native void writeAabbsToGpu(); + + public native @ByVal cl_mem getAabbBufferWS(); + public native int getNumOverlap(); + public native @ByVal cl_mem getOverlappingPairBuffer(); + + public native @ByRef b3Int4OCLArray getOverlappingPairsGPU(); + public native @ByRef b3IntOCLArray getSmallAabbIndicesGPU(); + public native @ByRef b3IntOCLArray getLargeAabbIndicesGPU(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java new file mode 100644 index 00000000000..8c1625335c8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java @@ -0,0 +1,114 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**Until we get other contributions, only use SIMD on Windows, when using Visual Studio 2008 or later, and not double precision */ +// #ifdef B3_USE_SSE +// #endif // + +/**The b3SolverBody is an internal datastructure for the constraint solver. Only necessary data is packed to increase cache coherence/performance. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuSolverBody extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuSolverBody() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuSolverBody(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuSolverBody(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuSolverBody position(long position) { + return (b3GpuSolverBody)super.position(position); + } + @Override public b3GpuSolverBody getPointer(long i) { + return new b3GpuSolverBody((Pointer)this).offsetAddress(i); + } + + // b3Transform m_worldTransformUnused; + public native @ByRef b3Vector3 m_deltaLinearVelocity(); public native b3GpuSolverBody m_deltaLinearVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_deltaAngularVelocity(); public native b3GpuSolverBody m_deltaAngularVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_angularFactor(); public native b3GpuSolverBody m_angularFactor(b3Vector3 setter); + public native @ByRef b3Vector3 m_linearFactor(); public native b3GpuSolverBody m_linearFactor(b3Vector3 setter); + public native @ByRef b3Vector3 m_invMass(); public native b3GpuSolverBody m_invMass(b3Vector3 setter); + public native @ByRef b3Vector3 m_pushVelocity(); public native b3GpuSolverBody m_pushVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_turnVelocity(); public native b3GpuSolverBody m_turnVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_linearVelocity(); public native b3GpuSolverBody m_linearVelocity(b3Vector3 setter); + public native @ByRef b3Vector3 m_angularVelocity(); public native b3GpuSolverBody m_angularVelocity(b3Vector3 setter); + public native Pointer m_originalBody(); public native b3GpuSolverBody m_originalBody(Pointer setter); + public native int m_originalBodyIndex(); public native b3GpuSolverBody m_originalBodyIndex(int setter); + + public native int padding(int i); public native b3GpuSolverBody padding(int i, int setter); + @MemberGetter public native IntPointer padding(); + + /* + void setWorldTransform(const b3Transform& worldTransform) + { + m_worldTransform = worldTransform; + } + + const b3Transform& getWorldTransform() const + { + return m_worldTransform; + } + */ + public native void getVelocityInLocalPointObsolete(@Const @ByRef b3Vector3 rel_pos, @ByRef b3Vector3 velocity); + + public native void getAngularVelocity(@ByRef b3Vector3 angVel); + + //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position + public native void applyImpulse(@Const @ByRef b3Vector3 linearComponent, @Const @ByRef b3Vector3 angularComponent, @Cast("const b3Scalar") float impulseMagnitude); + + public native void internalApplyPushImpulse(@Const @ByRef b3Vector3 linearComponent, @Const @ByRef b3Vector3 angularComponent, @Cast("b3Scalar") float impulseMagnitude); + + public native @Const @ByRef b3Vector3 getDeltaLinearVelocity(); + + public native @Const @ByRef b3Vector3 getDeltaAngularVelocity(); + + public native @Const @ByRef b3Vector3 getPushVelocity(); + + public native @Const @ByRef b3Vector3 getTurnVelocity(); + + //////////////////////////////////////////////// + /**some internal methods, don't use them */ + + public native @ByRef b3Vector3 internalGetDeltaLinearVelocity(); + + public native @ByRef b3Vector3 internalGetDeltaAngularVelocity(); + + public native @Const @ByRef b3Vector3 internalGetAngularFactor(); + + public native @Const @ByRef b3Vector3 internalGetInvMass(); + + public native void internalSetInvMass(@Const @ByRef b3Vector3 invMass); + + public native @ByRef b3Vector3 internalGetPushVelocity(); + + public native @ByRef b3Vector3 internalGetTurnVelocity(); + + public native void internalGetVelocityInLocalPointObsolete(@Const @ByRef b3Vector3 rel_pos, @ByRef b3Vector3 velocity); + + public native void internalGetAngularVelocity(@ByRef b3Vector3 angVel); + + //Optimization for the iterative solver: avoid calculating constant terms involving inertia, normal, relative position + public native void internalApplyImpulse(@Const @ByRef b3Vector3 linearComponent, @Const @ByRef b3Vector3 angularComponent, @Cast("const b3Scalar") float impulseMagnitude); + + public native void writebackVelocity(); + + public native void writebackVelocityAndTransform(@Cast("b3Scalar") float timeStep, @Cast("b3Scalar") float splitImpulseTurnErp); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java new file mode 100644 index 00000000000..037a99b916d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +//#define NO_FRICTION_TANGENTIALS 1 + +/**1D constraint along a normal axis between bodyA and bodyB. It can be combined to solve contact and friction constraints. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3GpuSolverConstraint extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3GpuSolverConstraint() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3GpuSolverConstraint(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3GpuSolverConstraint(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3GpuSolverConstraint position(long position) { + return (b3GpuSolverConstraint)super.position(position); + } + @Override public b3GpuSolverConstraint getPointer(long i) { + return new b3GpuSolverConstraint((Pointer)this).offsetAddress(i); + } + + + public native @ByRef b3Vector3 m_relpos1CrossNormal(); public native b3GpuSolverConstraint m_relpos1CrossNormal(b3Vector3 setter); + public native @ByRef b3Vector3 m_contactNormal(); public native b3GpuSolverConstraint m_contactNormal(b3Vector3 setter); + + public native @ByRef b3Vector3 m_relpos2CrossNormal(); public native b3GpuSolverConstraint m_relpos2CrossNormal(b3Vector3 setter); + //b3Vector3 m_contactNormal2;//usually m_contactNormal2 == -m_contactNormal + + public native @ByRef b3Vector3 m_angularComponentA(); public native b3GpuSolverConstraint m_angularComponentA(b3Vector3 setter); + public native @ByRef b3Vector3 m_angularComponentB(); public native b3GpuSolverConstraint m_angularComponentB(b3Vector3 setter); + + public native @Cast("b3Scalar") float m_appliedPushImpulse(); public native b3GpuSolverConstraint m_appliedPushImpulse(float setter); + public native @Cast("b3Scalar") float m_appliedImpulse(); public native b3GpuSolverConstraint m_appliedImpulse(float setter); + public native int m_padding1(); public native b3GpuSolverConstraint m_padding1(int setter); + public native int m_padding2(); public native b3GpuSolverConstraint m_padding2(int setter); + public native @Cast("b3Scalar") float m_friction(); public native b3GpuSolverConstraint m_friction(float setter); + public native @Cast("b3Scalar") float m_jacDiagABInv(); public native b3GpuSolverConstraint m_jacDiagABInv(float setter); + public native @Cast("b3Scalar") float m_rhs(); public native b3GpuSolverConstraint m_rhs(float setter); + public native @Cast("b3Scalar") float m_cfm(); public native b3GpuSolverConstraint m_cfm(float setter); + + public native @Cast("b3Scalar") float m_lowerLimit(); public native b3GpuSolverConstraint m_lowerLimit(float setter); + public native @Cast("b3Scalar") float m_upperLimit(); public native b3GpuSolverConstraint m_upperLimit(float setter); + public native @Cast("b3Scalar") float m_rhsPenetration(); public native b3GpuSolverConstraint m_rhsPenetration(float setter); + public native Pointer m_originalContactPoint(); public native b3GpuSolverConstraint m_originalContactPoint(Pointer setter); + public native int m_originalConstraintIndex(); public native b3GpuSolverConstraint m_originalConstraintIndex(int setter); + public native @Cast("b3Scalar") float m_unusedPadding4(); public native b3GpuSolverConstraint m_unusedPadding4(float setter); + + public native int m_overrideNumSolverIterations(); public native b3GpuSolverConstraint m_overrideNumSolverIterations(int setter); + public native int m_frictionIndex(); public native b3GpuSolverConstraint m_frictionIndex(int setter); + public native int m_solverBodyIdA(); public native b3GpuSolverConstraint m_solverBodyIdA(int setter); + public native int m_solverBodyIdB(); public native b3GpuSolverConstraint m_solverBodyIdB(int setter); + + /** enum b3GpuSolverConstraint::b3SolverConstraintType */ + public static final int + B3_SOLVER_CONTACT_1D = 0, + B3_SOLVER_FRICTION_1D = 1; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java new file mode 100644 index 00000000000..7c5ba118258 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java @@ -0,0 +1,58 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**The b3IndexedMesh indexes a single vertex and index array. Multiple b3IndexedMesh objects can be passed into a b3TriangleIndexVertexArray using addIndexedMesh. + * Instead of the number of indices, we pass the number of triangles. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3IndexedMesh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3IndexedMesh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3IndexedMesh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3IndexedMesh position(long position) { + return (b3IndexedMesh)super.position(position); + } + @Override public b3IndexedMesh getPointer(long i) { + return new b3IndexedMesh((Pointer)this).offsetAddress(i); + } + + + public native int m_numTriangles(); public native b3IndexedMesh m_numTriangles(int setter); + public native @Cast("const unsigned char*") BytePointer m_triangleIndexBase(); public native b3IndexedMesh m_triangleIndexBase(BytePointer setter); + // Size in byte of the indices for one triangle (3*sizeof(index_type) if the indices are tightly packed) + public native int m_triangleIndexStride(); public native b3IndexedMesh m_triangleIndexStride(int setter); + public native int m_numVertices(); public native b3IndexedMesh m_numVertices(int setter); + public native @Cast("const unsigned char*") BytePointer m_vertexBase(); public native b3IndexedMesh m_vertexBase(BytePointer setter); + // Size of a vertex, in bytes + public native int m_vertexStride(); public native b3IndexedMesh m_vertexStride(int setter); + + // The index type is set when adding an indexed mesh to the + // b3TriangleIndexVertexArray, do not set it manually + public native @Cast("PHY_ScalarType") int m_indexType(); public native b3IndexedMesh m_indexType(int setter); + + // The vertex type has a default type similar to Bullet's precision mode (float or double) + // but can be set manually if you for example run Bullet with double precision but have + // mesh data in single precision.. + public native @Cast("PHY_ScalarType") int m_vertexType(); public native b3IndexedMesh m_vertexType(int setter); + + public b3IndexedMesh() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java new file mode 100644 index 00000000000..f506faa6391 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3InertiaDataArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3InertiaDataArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3InertiaDataArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3InertiaDataArray position(long position) { + return (b3InertiaDataArray)super.position(position); + } + @Override public b3InertiaDataArray getPointer(long i) { + return new b3InertiaDataArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3InertiaDataArray put(@Const @ByRef b3InertiaDataArray other); + public b3InertiaDataArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3InertiaDataArray(@Const @ByRef b3InertiaDataArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3InertiaDataArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3InertiaData at(int n); + + public native @ByRef @Name("operator []") b3InertiaData get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3InertiaData()") b3InertiaData fillData); + public native void resize(int newsize); + public native @ByRef b3InertiaData expandNonInitializing(); + + public native @ByRef b3InertiaData expand(@Const @ByRef(nullValue = "b3InertiaData()") b3InertiaData fillValue); + public native @ByRef b3InertiaData expand(); + + public native void push_back(@Const @ByRef b3InertiaData _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3InertiaDataArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java new file mode 100644 index 00000000000..f0f486f36c8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3InertiaDataOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3InertiaDataOCLArray(Pointer p) { super(p); } + + public b3InertiaDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3InertiaDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3InertiaData _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3InertiaData _Val); + + public native @ByVal b3InertiaData forcedAt(@Cast("size_t") long n); + + public native @ByVal b3InertiaData at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3InertiaDataArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3InertiaDataArray srcArray); + + public native void copyFromHostPointer(@Const b3InertiaData src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3InertiaData src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3InertiaDataArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3InertiaDataArray destArray); + + public native void copyToHostPointer(b3InertiaData destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3InertiaData destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3InertiaDataOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java new file mode 100644 index 00000000000..47ed112f106 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3Int2OCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Int2OCLArray(Pointer p) { super(p); } + + public b3Int2OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3Int2OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3Int2 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3Int2 _Val); + + public native @ByVal b3Int2 forcedAt(@Cast("size_t") long n); + + public native @ByVal b3Int2 at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3Int2Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3Int2Array srcArray); + + public native void copyFromHostPointer(@Const b3Int2 src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3Int2 src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3Int2Array destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3Int2Array destArray); + + public native void copyToHostPointer(b3Int2 destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3Int2 destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3Int2OCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java new file mode 100644 index 00000000000..3401f745a2a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3Int4OCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Int4OCLArray(Pointer p) { super(p); } + + public b3Int4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3Int4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3Int4 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3Int4 _Val); + + public native @ByVal b3Int4 forcedAt(@Cast("size_t") long n); + + public native @ByVal b3Int4 at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3Int4Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3Int4Array srcArray); + + public native void copyFromHostPointer(@Const b3Int4 src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3Int4 src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3Int4Array destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3Int4Array destArray); + + public native void copyToHostPointer(b3Int4 destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3Int4 destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3Int4OCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java new file mode 100644 index 00000000000..39db1c42412 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java @@ -0,0 +1,39 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3IntIndexData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3IntIndexData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3IntIndexData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3IntIndexData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3IntIndexData position(long position) { + return (b3IntIndexData)super.position(position); + } + @Override public b3IntIndexData getPointer(long i) { + return new b3IntIndexData((Pointer)this).offsetAddress(i); + } + + public native int m_value(); public native b3IntIndexData m_value(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java new file mode 100644 index 00000000000..22edaf85c40 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java @@ -0,0 +1,84 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3IntOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3IntOCLArray(Pointer p) { super(p); } + + public b3IntOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3IntOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(int _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(int _Val); + + public native int forcedAt(@Cast("size_t") long n); + + public native int at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3IntArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3IntArray srcArray); + + public native void copyFromHostPointer(@Const IntPointer src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const IntPointer src, @Cast("size_t") long numElems); + public native void copyFromHostPointer(@Const IntBuffer src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const IntBuffer src, @Cast("size_t") long numElems); + public native void copyFromHostPointer(@Const int[] src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const int[] src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3IntArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3IntArray destArray); + + public native void copyToHostPointer(IntPointer destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(IntPointer destPtr, @Cast("size_t") long numElem); + public native void copyToHostPointer(IntBuffer destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(IntBuffer destPtr, @Cast("size_t") long numElem); + public native void copyToHostPointer(int[] destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(int[] destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3IntOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java new file mode 100644 index 00000000000..72ac26cb20f --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3InternalTriangleIndexCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3InternalTriangleIndexCallback(Pointer p) { super(p); } + + public native void internalProcessTriangleIndex(b3Vector3 triangle, int partId, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java new file mode 100644 index 00000000000..c6a44eafecd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +//struct b3InertiaData; +//b3InertiaData + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3JacobiSolverInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3JacobiSolverInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3JacobiSolverInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3JacobiSolverInfo position(long position) { + return (b3JacobiSolverInfo)super.position(position); + } + @Override public b3JacobiSolverInfo getPointer(long i) { + return new b3JacobiSolverInfo((Pointer)this).offsetAddress(i); + } + + public native int m_fixedBodyIndex(); public native b3JacobiSolverInfo m_fixedBodyIndex(int setter); + + public native float m_deltaTime(); public native b3JacobiSolverInfo m_deltaTime(float setter); + public native float m_positionDrift(); public native b3JacobiSolverInfo m_positionDrift(float setter); + public native float m_positionConstraintCoeff(); public native b3JacobiSolverInfo m_positionConstraintCoeff(float setter); + public native int m_numIterations(); public native b3JacobiSolverInfo m_numIterations(int setter); + + public b3JacobiSolverInfo() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java new file mode 100644 index 00000000000..2f67242fa74 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3KernelArgData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3KernelArgData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3KernelArgData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3KernelArgData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3KernelArgData position(long position) { + return (b3KernelArgData)super.position(position); + } + @Override public b3KernelArgData getPointer(long i) { + return new b3KernelArgData((Pointer)this).offsetAddress(i); + } + + public native int m_isBuffer(); public native b3KernelArgData m_isBuffer(int setter); + public native int m_argIndex(); public native b3KernelArgData m_argIndex(int setter); + public native int m_argSizeInBytes(); public native b3KernelArgData m_argSizeInBytes(int setter); + public native int m_unusedPadding(); public native b3KernelArgData m_unusedPadding(int setter); + public native @ByRef cl_mem m_clBuffer(); public native b3KernelArgData m_clBuffer(cl_mem setter); + public native @Cast("unsigned char") byte m_argData(int i); public native b3KernelArgData m_argData(int i, byte setter); + @MemberGetter public native @Cast("unsigned char*") BytePointer m_argData(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java new file mode 100644 index 00000000000..ef5766d47b0 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java @@ -0,0 +1,64 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3LauncherCL extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3LauncherCL(Pointer p) { super(p); } + + public native @ByRef b3UnsignedCharOCLArrayArray m_arrays(); public native b3LauncherCL m_arrays(b3UnsignedCharOCLArrayArray setter); + + public b3LauncherCL(@ByVal cl_command_queue queue, @ByVal cl_kernel kernel, @Cast("const char*") BytePointer name) { super((Pointer)null); allocate(queue, kernel, name); } + private native void allocate(@ByVal cl_command_queue queue, @ByVal cl_kernel kernel, @Cast("const char*") BytePointer name); + public b3LauncherCL(@ByVal cl_command_queue queue, @ByVal cl_kernel kernel, String name) { super((Pointer)null); allocate(queue, kernel, name); } + private native void allocate(@ByVal cl_command_queue queue, @ByVal cl_kernel kernel, String name); + + public native void setBuffer(@ByVal cl_mem clBuffer); + + public native void setBuffers(b3BufferInfoCL buffInfo, int n); + + public native int getSerializationBufferSize(); + + public native int deserializeArgs(@Cast("unsigned char*") BytePointer buf, int bufSize, @ByVal cl_context ctx); + public native int deserializeArgs(@Cast("unsigned char*") ByteBuffer buf, int bufSize, @ByVal cl_context ctx); + public native int deserializeArgs(@Cast("unsigned char*") byte[] buf, int bufSize, @ByVal cl_context ctx); + + public native int validateResults(@Cast("unsigned char*") BytePointer goldBuffer, int goldBufferCapacity, @ByVal cl_context ctx); + public native int validateResults(@Cast("unsigned char*") ByteBuffer goldBuffer, int goldBufferCapacity, @ByVal cl_context ctx); + public native int validateResults(@Cast("unsigned char*") byte[] goldBuffer, int goldBufferCapacity, @ByVal cl_context ctx); + + public native int serializeArguments(@Cast("unsigned char*") BytePointer destBuffer, int destBufferCapacity); + public native int serializeArguments(@Cast("unsigned char*") ByteBuffer destBuffer, int destBufferCapacity); + public native int serializeArguments(@Cast("unsigned char*") byte[] destBuffer, int destBufferCapacity); + + public native int getNumArguments(); + + public native @ByVal b3KernelArgData getArgument(int index); + + public native void serializeToFile(@Cast("const char*") BytePointer fileName, int numWorkItems); + public native void serializeToFile(String fileName, int numWorkItems); + + public native void launch1D(int numThreads, int localSize/*=64*/); + public native void launch1D(int numThreads); + + public native void launch2D(int numThreadsX, int numThreadsY, int localSizeX, int localSizeY); + + public native void enableSerialization(@Cast("bool") boolean serialize); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java new file mode 100644 index 00000000000..79877fe441e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3MeshPartData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3MeshPartData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3MeshPartData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3MeshPartData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3MeshPartData position(long position) { + return (b3MeshPartData)super.position(position); + } + @Override public b3MeshPartData getPointer(long i) { + return new b3MeshPartData((Pointer)this).offsetAddress(i); + } + + public native b3Vector3FloatData m_vertices3f(); public native b3MeshPartData m_vertices3f(b3Vector3FloatData setter); + public native b3Vector3DoubleData m_vertices3d(); public native b3MeshPartData m_vertices3d(b3Vector3DoubleData setter); + + public native b3IntIndexData m_indices32(); public native b3MeshPartData m_indices32(b3IntIndexData setter); + public native b3ShortIntIndexTripletData m_3indices16(); public native b3MeshPartData m_3indices16(b3ShortIntIndexTripletData setter); + public native b3CharIndexTripletData m_3indices8(); public native b3MeshPartData m_3indices8(b3CharIndexTripletData setter); + + public native b3ShortIntIndexData m_indices16(); public native b3MeshPartData m_indices16(b3ShortIntIndexData setter); //backwards compatibility + + public native int m_numTriangles(); public native b3MeshPartData m_numTriangles(int setter); //length of m_indices = m_numTriangles + public native int m_numVertices(); public native b3MeshPartData m_numVertices(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java new file mode 100644 index 00000000000..d1d1c60e50e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java @@ -0,0 +1,28 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3NodeOverlapCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3NodeOverlapCallback(Pointer p) { super(p); } + + + public native void processNode(int subPart, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java new file mode 100644 index 00000000000..4d07644d3f3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java @@ -0,0 +1,78 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3OpenCLDeviceInfo extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3OpenCLDeviceInfo() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3OpenCLDeviceInfo(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OpenCLDeviceInfo(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3OpenCLDeviceInfo position(long position) { + return (b3OpenCLDeviceInfo)super.position(position); + } + @Override public b3OpenCLDeviceInfo getPointer(long i) { + return new b3OpenCLDeviceInfo((Pointer)this).offsetAddress(i); + } + + public native @Cast("char") byte m_deviceName(int i); public native b3OpenCLDeviceInfo m_deviceName(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_deviceName(); + public native @Cast("char") byte m_deviceVendor(int i); public native b3OpenCLDeviceInfo m_deviceVendor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_deviceVendor(); + public native @Cast("char") byte m_driverVersion(int i); public native b3OpenCLDeviceInfo m_driverVersion(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_driverVersion(); + public native @Cast("char") byte m_deviceExtensions(int i); public native b3OpenCLDeviceInfo m_deviceExtensions(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_deviceExtensions(); + + public native int m_deviceType(); public native b3OpenCLDeviceInfo m_deviceType(int setter); + public native @Cast("unsigned int") int m_computeUnits(); public native b3OpenCLDeviceInfo m_computeUnits(int setter); + public native @Cast("size_t") long m_workitemDims(); public native b3OpenCLDeviceInfo m_workitemDims(long setter); + public native @Cast("size_t") long m_workItemSize(int i); public native b3OpenCLDeviceInfo m_workItemSize(int i, long setter); + @MemberGetter public native @Cast("size_t*") SizeTPointer m_workItemSize(); + public native @Cast("size_t") long m_image2dMaxWidth(); public native b3OpenCLDeviceInfo m_image2dMaxWidth(long setter); + public native @Cast("size_t") long m_image2dMaxHeight(); public native b3OpenCLDeviceInfo m_image2dMaxHeight(long setter); + public native @Cast("size_t") long m_image3dMaxWidth(); public native b3OpenCLDeviceInfo m_image3dMaxWidth(long setter); + public native @Cast("size_t") long m_image3dMaxHeight(); public native b3OpenCLDeviceInfo m_image3dMaxHeight(long setter); + public native @Cast("size_t") long m_image3dMaxDepth(); public native b3OpenCLDeviceInfo m_image3dMaxDepth(long setter); + public native @Cast("size_t") long m_workgroupSize(); public native b3OpenCLDeviceInfo m_workgroupSize(long setter); + public native @Cast("unsigned int") int m_clockFrequency(); public native b3OpenCLDeviceInfo m_clockFrequency(int setter); + public native @Cast("unsigned long") long m_constantBufferSize(); public native b3OpenCLDeviceInfo m_constantBufferSize(long setter); + public native @Cast("unsigned long") long m_localMemSize(); public native b3OpenCLDeviceInfo m_localMemSize(long setter); + public native @Cast("unsigned long") long m_globalMemSize(); public native b3OpenCLDeviceInfo m_globalMemSize(long setter); + public native @Cast("bool") boolean m_errorCorrectionSupport(); public native b3OpenCLDeviceInfo m_errorCorrectionSupport(boolean setter); + public native int m_localMemType(); public native b3OpenCLDeviceInfo m_localMemType(int setter); + public native @Cast("unsigned int") int m_maxReadImageArgs(); public native b3OpenCLDeviceInfo m_maxReadImageArgs(int setter); + public native @Cast("unsigned int") int m_maxWriteImageArgs(); public native b3OpenCLDeviceInfo m_maxWriteImageArgs(int setter); + + public native @Cast("unsigned int") int m_addressBits(); public native b3OpenCLDeviceInfo m_addressBits(int setter); + public native @Cast("unsigned long") long m_maxMemAllocSize(); public native b3OpenCLDeviceInfo m_maxMemAllocSize(long setter); + public native int m_queueProperties(); public native b3OpenCLDeviceInfo m_queueProperties(int setter); + public native @Cast("bool") boolean m_imageSupport(); public native b3OpenCLDeviceInfo m_imageSupport(boolean setter); + public native @Cast("unsigned int") int m_vecWidthChar(); public native b3OpenCLDeviceInfo m_vecWidthChar(int setter); + public native @Cast("unsigned int") int m_vecWidthShort(); public native b3OpenCLDeviceInfo m_vecWidthShort(int setter); + public native @Cast("unsigned int") int m_vecWidthInt(); public native b3OpenCLDeviceInfo m_vecWidthInt(int setter); + public native @Cast("unsigned int") int m_vecWidthLong(); public native b3OpenCLDeviceInfo m_vecWidthLong(int setter); + public native @Cast("unsigned int") int m_vecWidthFloat(); public native b3OpenCLDeviceInfo m_vecWidthFloat(int setter); + public native @Cast("unsigned int") int m_vecWidthDouble(); public native b3OpenCLDeviceInfo m_vecWidthDouble(int setter); + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java new file mode 100644 index 00000000000..a90a9286424 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3OpenCLPlatformInfo extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OpenCLPlatformInfo(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3OpenCLPlatformInfo(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3OpenCLPlatformInfo position(long position) { + return (b3OpenCLPlatformInfo)super.position(position); + } + @Override public b3OpenCLPlatformInfo getPointer(long i) { + return new b3OpenCLPlatformInfo((Pointer)this).offsetAddress(i); + } + + public native @Cast("char") byte m_platformVendor(int i); public native b3OpenCLPlatformInfo m_platformVendor(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_platformVendor(); + public native @Cast("char") byte m_platformName(int i); public native b3OpenCLPlatformInfo m_platformName(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_platformName(); + public native @Cast("char") byte m_platformVersion(int i); public native b3OpenCLPlatformInfo m_platformVersion(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_platformVersion(); + + public b3OpenCLPlatformInfo() { super((Pointer)null); allocate(); } + private native void allocate(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java new file mode 100644 index 00000000000..a20d2450254 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java @@ -0,0 +1,98 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**C++ API for OpenCL utilities: convenience functions */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3OpenCLUtils extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3OpenCLUtils() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3OpenCLUtils(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OpenCLUtils(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3OpenCLUtils position(long position) { + return (b3OpenCLUtils)super.position(position); + } + @Override public b3OpenCLUtils getPointer(long i) { + return new b3OpenCLUtils((Pointer)this).offsetAddress(i); + } + + /** CL Context optionally takes a GL context. This is a generic type because we don't really want this code + * to have to understand GL types. It is a HGLRC in _WIN32 or a GLXContext otherwise. */ + public static native @ByVal cl_context createContextFromType(int deviceType, IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); + public static native @ByVal cl_context createContextFromType(int deviceType, IntPointer pErrNum); + public static native @ByVal cl_context createContextFromType(int deviceType, IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); + public static native @ByVal cl_context createContextFromType(int deviceType, IntBuffer pErrNum); + public static native @ByVal cl_context createContextFromType(int deviceType, int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); + public static native @ByVal cl_context createContextFromType(int deviceType, int[] pErrNum); + + public static native int getNumDevices(@ByVal cl_context cxMainContext); + public static native @ByVal cl_device_id getDevice(@ByVal cl_context cxMainContext, int nr); + + public static native void getDeviceInfo(@ByVal cl_device_id device, b3OpenCLDeviceInfo info); + + public static native void printDeviceInfo(@ByVal cl_device_id device); + + public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, IntPointer pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, @Cast("const char*") BytePointer additionalMacros/*=""*/); + public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName); + public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, IntBuffer pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, String additionalMacros/*=""*/); + public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName); + public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, int[] pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, @Cast("const char*") BytePointer additionalMacros/*=""*/); + public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, IntPointer pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, String additionalMacros/*=""*/); + public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, IntBuffer pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, @Cast("const char*") BytePointer additionalMacros/*=""*/); + public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, int[] pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, String additionalMacros/*=""*/); + + //optional + public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, IntPointer pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource); + public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, IntBuffer pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource); + public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, int[] pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, IntPointer pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, IntBuffer pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, int[] pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + + //the following optional APIs provide access using specific platform information + public static native int getNumPlatforms(IntPointer pErrNum/*=0*/); + public static native int getNumPlatforms(); + public static native int getNumPlatforms(IntBuffer pErrNum/*=0*/); + public static native int getNumPlatforms(int[] pErrNum/*=0*/); + /**get the nr'th platform, where nr is in the range [0..getNumPlatforms) */ + public static native @ByVal cl_platform_id getPlatform(int nr, IntPointer pErrNum/*=0*/); + public static native @ByVal cl_platform_id getPlatform(int nr); + public static native @ByVal cl_platform_id getPlatform(int nr, IntBuffer pErrNum/*=0*/); + public static native @ByVal cl_platform_id getPlatform(int nr, int[] pErrNum/*=0*/); + + public static native void getPlatformInfo(@ByVal cl_platform_id platform, b3OpenCLPlatformInfo platformInfo); + + public static native void printPlatformInfo(@ByVal cl_platform_id platform); + + public static native @Cast("const char*") BytePointer getSdkVendorName(); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntPointer pErrNum); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntBuffer pErrNum); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, int[] pErrNum); + public static native void setCachePath(@Cast("const char*") BytePointer path); + public static native void setCachePath(String path); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java new file mode 100644 index 00000000000..1f9d690cbfd --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java @@ -0,0 +1,52 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**The b3OptimizedBvh extends the b3QuantizedBvh to create AABB tree for triangle meshes, through the b3StridingMeshInterface. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3OptimizedBvh extends b3QuantizedBvh { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OptimizedBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3OptimizedBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3OptimizedBvh position(long position) { + return (b3OptimizedBvh)super.position(position); + } + @Override public b3OptimizedBvh getPointer(long i) { + return new b3OptimizedBvh((Pointer)this).offsetAddress(i); + } + + public b3OptimizedBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void build(b3StridingMeshInterface triangles, @Cast("bool") boolean useQuantizedAabbCompression, @Const @ByRef b3Vector3 bvhAabbMin, @Const @ByRef b3Vector3 bvhAabbMax); + + public native void refit(b3StridingMeshInterface triangles, @Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax); + + public native void refitPartial(b3StridingMeshInterface triangles, @Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax); + + public native void updateBvhNodes(b3StridingMeshInterface meshInterface, int firstNode, int endNode, int index); + + /** Data buffer MUST be 16 byte aligned */ + public native @Cast("bool") boolean serializeInPlace(Pointer o_alignedDataBuffer, @Cast("unsigned") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + /**deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' */ + public static native b3OptimizedBvh deSerializeInPlace(Pointer i_alignedDataBuffer, @Cast("unsigned int") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java new file mode 100644 index 00000000000..42e28493b36 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3OptimizedBvhArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OptimizedBvhArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3OptimizedBvhArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3OptimizedBvhArray position(long position) { + return (b3OptimizedBvhArray)super.position(position); + } + @Override public b3OptimizedBvhArray getPointer(long i) { + return new b3OptimizedBvhArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3OptimizedBvhArray put(@Const @ByRef b3OptimizedBvhArray other); + public b3OptimizedBvhArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3OptimizedBvhArray(@Const @ByRef b3OptimizedBvhArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3OptimizedBvhArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef b3OptimizedBvh at(int n); + + public native @ByPtrRef @Name("operator []") b3OptimizedBvh get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef b3OptimizedBvh fillData/*=b3OptimizedBvh*()*/); + public native void resize(int newsize); + public native @ByPtrRef b3OptimizedBvh expandNonInitializing(); + + public native @ByPtrRef b3OptimizedBvh expand(@ByPtrRef b3OptimizedBvh fillValue/*=b3OptimizedBvh*()*/); + public native @ByPtrRef b3OptimizedBvh expand(); + + public native void push_back(@ByPtrRef b3OptimizedBvh _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef b3OptimizedBvh key); + + public native int findLinearSearch(@ByPtrRef b3OptimizedBvh key); + + public native int findLinearSearch2(@ByPtrRef b3OptimizedBvh key); + + public native void remove(@ByPtrRef b3OptimizedBvh key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3OptimizedBvhArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java new file mode 100644 index 00000000000..e5513a844b9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java @@ -0,0 +1,56 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/** b3OptimizedBvhNode contains both internal and leaf node information. + * Total node size is 44 bytes / node. You can use the compressed version of 16 bytes. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3OptimizedBvhNode extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3OptimizedBvhNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3OptimizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OptimizedBvhNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3OptimizedBvhNode position(long position) { + return (b3OptimizedBvhNode)super.position(position); + } + @Override public b3OptimizedBvhNode getPointer(long i) { + return new b3OptimizedBvhNode((Pointer)this).offsetAddress(i); + } + + + //32 bytes + public native @ByRef b3Vector3 m_aabbMinOrg(); public native b3OptimizedBvhNode m_aabbMinOrg(b3Vector3 setter); + public native @ByRef b3Vector3 m_aabbMaxOrg(); public native b3OptimizedBvhNode m_aabbMaxOrg(b3Vector3 setter); + + //4 + public native int m_escapeIndex(); public native b3OptimizedBvhNode m_escapeIndex(int setter); + + //8 + //for child nodes + public native int m_subPart(); public native b3OptimizedBvhNode m_subPart(int setter); + public native int m_triangleIndex(); public native b3OptimizedBvhNode m_triangleIndex(int setter); + + //pad the size to 64 bytes + public native @Cast("char") byte m_padding(int i); public native b3OptimizedBvhNode m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java new file mode 100644 index 00000000000..17535adbb34 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3OptimizedBvhNodeDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3OptimizedBvhNodeDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3OptimizedBvhNodeDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OptimizedBvhNodeDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3OptimizedBvhNodeDoubleData position(long position) { + return (b3OptimizedBvhNodeDoubleData)super.position(position); + } + @Override public b3OptimizedBvhNodeDoubleData getPointer(long i) { + return new b3OptimizedBvhNodeDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3DoubleData m_aabbMinOrg(); public native b3OptimizedBvhNodeDoubleData m_aabbMinOrg(b3Vector3DoubleData setter); + public native @ByRef b3Vector3DoubleData m_aabbMaxOrg(); public native b3OptimizedBvhNodeDoubleData m_aabbMaxOrg(b3Vector3DoubleData setter); + public native int m_escapeIndex(); public native b3OptimizedBvhNodeDoubleData m_escapeIndex(int setter); + public native int m_subPart(); public native b3OptimizedBvhNodeDoubleData m_subPart(int setter); + public native int m_triangleIndex(); public native b3OptimizedBvhNodeDoubleData m_triangleIndex(int setter); + public native @Cast("char") byte m_pad(int i); public native b3OptimizedBvhNodeDoubleData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java new file mode 100644 index 00000000000..a691d9569d8 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3OptimizedBvhNodeFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3OptimizedBvhNodeFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3OptimizedBvhNodeFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3OptimizedBvhNodeFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3OptimizedBvhNodeFloatData position(long position) { + return (b3OptimizedBvhNodeFloatData)super.position(position); + } + @Override public b3OptimizedBvhNodeFloatData getPointer(long i) { + return new b3OptimizedBvhNodeFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3FloatData m_aabbMinOrg(); public native b3OptimizedBvhNodeFloatData m_aabbMinOrg(b3Vector3FloatData setter); + public native @ByRef b3Vector3FloatData m_aabbMaxOrg(); public native b3OptimizedBvhNodeFloatData m_aabbMaxOrg(b3Vector3FloatData setter); + public native int m_escapeIndex(); public native b3OptimizedBvhNodeFloatData m_escapeIndex(int setter); + public native int m_subPart(); public native b3OptimizedBvhNodeFloatData m_subPart(int setter); + public native int m_triangleIndex(); public native b3OptimizedBvhNodeFloatData m_triangleIndex(int setter); + public native @Cast("char") byte m_pad(int i); public native b3OptimizedBvhNodeFloatData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java new file mode 100644 index 00000000000..a87f7902e5b --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java @@ -0,0 +1,46 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3ParamsGridBroadphaseCL extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ParamsGridBroadphaseCL() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ParamsGridBroadphaseCL(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ParamsGridBroadphaseCL(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ParamsGridBroadphaseCL position(long position) { + return (b3ParamsGridBroadphaseCL)super.position(position); + } + @Override public b3ParamsGridBroadphaseCL getPointer(long i) { + return new b3ParamsGridBroadphaseCL((Pointer)this).offsetAddress(i); + } + + public native float m_invCellSize(int i); public native b3ParamsGridBroadphaseCL m_invCellSize(int i, float setter); + @MemberGetter public native FloatPointer m_invCellSize(); + public native int m_gridSize(int i); public native b3ParamsGridBroadphaseCL m_gridSize(int i, int setter); + @MemberGetter public native IntPointer m_gridSize(); + + public native int getMaxBodiesPerCell(); + + public native void setMaxBodiesPerCell(int maxOverlap); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java new file mode 100644 index 00000000000..2c1096b4019 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java @@ -0,0 +1,34 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3PrefixScanFloat4CL extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3PrefixScanFloat4CL(Pointer p) { super(p); } + + public b3PrefixScanFloat4CL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int size/*=0*/) { super((Pointer)null); allocate(ctx, device, queue, size); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int size/*=0*/); + public b3PrefixScanFloat4CL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, device, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + + public native void execute(@ByRef b3Vector3OCLArray src, @ByRef b3Vector3OCLArray dst, int n, b3Vector3 sum/*=0*/); + public native void execute(@ByRef b3Vector3OCLArray src, @ByRef b3Vector3OCLArray dst, int n); + public native void executeHost(@ByRef b3Vector3Array src, @ByRef b3Vector3Array dst, int n, b3Vector3 sum); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java new file mode 100644 index 00000000000..7ec03af612c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java @@ -0,0 +1,108 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**The b3QuantizedBvh class stores an AABB tree that can be quickly traversed on CPU and Cell SPU. + * It is used by the b3BvhTriangleMeshShape as midphase + * It is recommended to use quantization for better performance and lower memory requirements. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3QuantizedBvh extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3QuantizedBvh(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3QuantizedBvh(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3QuantizedBvh position(long position) { + return (b3QuantizedBvh)super.position(position); + } + @Override public b3QuantizedBvh getPointer(long i) { + return new b3QuantizedBvh((Pointer)this).offsetAddress(i); + } + + /** enum b3QuantizedBvh::b3TraversalMode */ + public static final int + TRAVERSAL_STACKLESS = 0, + TRAVERSAL_STACKLESS_CACHE_FRIENDLY = 1, + TRAVERSAL_RECURSIVE = 2; + + public native @ByRef b3Vector3 m_bvhAabbMin(); public native b3QuantizedBvh m_bvhAabbMin(b3Vector3 setter); + public native @ByRef b3Vector3 m_bvhAabbMax(); public native b3QuantizedBvh m_bvhAabbMax(b3Vector3 setter); + public native @ByRef b3Vector3 m_bvhQuantization(); public native b3QuantizedBvh m_bvhQuantization(b3Vector3 setter); + + public b3QuantizedBvh() { super((Pointer)null); allocate(); } + private native void allocate(); + + ///***************************************** expert/internal use only ************************* + public native void setQuantizationValues(@Const @ByRef b3Vector3 bvhAabbMin, @Const @ByRef b3Vector3 bvhAabbMax, @Cast("b3Scalar") float quantizationMargin/*=b3Scalar(1.0)*/); + public native void setQuantizationValues(@Const @ByRef b3Vector3 bvhAabbMin, @Const @ByRef b3Vector3 bvhAabbMax); + public native @Cast("QuantizedNodeArray*") @ByRef b3QuantizedBvhNodeArray getLeafNodeArray(); + /**buildInternal is expert use only: assumes that setQuantizationValues and LeafNodeArray are initialized */ + public native void buildInternal(); + ///***************************************** expert/internal use only ************************* + + public native void reportAabbOverlappingNodex(b3NodeOverlapCallback nodeCallback, @Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax); + public native void reportRayOverlappingNodex(b3NodeOverlapCallback nodeCallback, @Const @ByRef b3Vector3 raySource, @Const @ByRef b3Vector3 rayTarget); + public native void reportBoxCastOverlappingNodex(b3NodeOverlapCallback nodeCallback, @Const @ByRef b3Vector3 raySource, @Const @ByRef b3Vector3 rayTarget, @Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax); + + public native void quantize(@Cast("unsigned short*") ShortPointer out, @Const @ByRef b3Vector3 point, int isMax); + public native void quantize(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef b3Vector3 point, int isMax); + public native void quantize(@Cast("unsigned short*") short[] out, @Const @ByRef b3Vector3 point, int isMax); + + public native void quantizeWithClamp(@Cast("unsigned short*") ShortPointer out, @Const @ByRef b3Vector3 point2, int isMax); + public native void quantizeWithClamp(@Cast("unsigned short*") ShortBuffer out, @Const @ByRef b3Vector3 point2, int isMax); + public native void quantizeWithClamp(@Cast("unsigned short*") short[] out, @Const @ByRef b3Vector3 point2, int isMax); + + public native @ByVal b3Vector3 unQuantize(@Cast("const unsigned short*") ShortPointer vecIn); + public native @ByVal b3Vector3 unQuantize(@Cast("const unsigned short*") ShortBuffer vecIn); + public native @ByVal b3Vector3 unQuantize(@Cast("const unsigned short*") short[] vecIn); + + /**setTraversalMode let's you choose between stackless, recursive or stackless cache friendly tree traversal. Note this is only implemented for quantized trees. */ + public native void setTraversalMode(@Cast("b3QuantizedBvh::b3TraversalMode") int traversalMode); + + public native @Cast("QuantizedNodeArray*") @ByRef b3QuantizedBvhNodeArray getQuantizedNodeArray(); + + public native @Cast("BvhSubtreeInfoArray*") @ByRef b3BvhSubtreeInfoArray getSubtreeInfoArray(); + + //////////////////////////////////////////////////////////////////// + + /////Calculate space needed to store BVH for serialization + public native @Cast("unsigned") int calculateSerializeBufferSize(); + + /** Data buffer MUST be 16 byte aligned */ + public native @Cast("bool") boolean serialize(Pointer o_alignedDataBuffer, @Cast("unsigned") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + /**deSerializeInPlace loads and initializes a BVH from a buffer in memory 'in place' */ + public static native b3QuantizedBvh deSerializeInPlace(Pointer i_alignedDataBuffer, @Cast("unsigned int") int i_dataBufferSize, @Cast("bool") boolean i_swapEndian); + + public static native @Cast("unsigned int") int getAlignmentSerializationPadding(); + ////////////////////////////////////////////////////////////////////// + + public native int calculateSerializeBufferSizeNew(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + public native @Cast("const char*") BytePointer serialize(Pointer dataBuffer, b3Serializer serializer); + + public native void deSerializeFloat(@ByRef b3QuantizedBvhFloatData quantizedBvhFloatData); + + public native void deSerializeDouble(@ByRef b3QuantizedBvhDoubleData quantizedBvhDoubleData); + + //////////////////////////////////////////////////////////////////// + + public native @Cast("bool") boolean isQuantized(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java new file mode 100644 index 00000000000..4c4a9bfb7d7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3QuantizedBvhDoubleData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3QuantizedBvhDoubleData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3QuantizedBvhDoubleData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3QuantizedBvhDoubleData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3QuantizedBvhDoubleData position(long position) { + return (b3QuantizedBvhDoubleData)super.position(position); + } + @Override public b3QuantizedBvhDoubleData getPointer(long i) { + return new b3QuantizedBvhDoubleData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3DoubleData m_bvhAabbMin(); public native b3QuantizedBvhDoubleData m_bvhAabbMin(b3Vector3DoubleData setter); + public native @ByRef b3Vector3DoubleData m_bvhAabbMax(); public native b3QuantizedBvhDoubleData m_bvhAabbMax(b3Vector3DoubleData setter); + public native @ByRef b3Vector3DoubleData m_bvhQuantization(); public native b3QuantizedBvhDoubleData m_bvhQuantization(b3Vector3DoubleData setter); + public native int m_curNodeIndex(); public native b3QuantizedBvhDoubleData m_curNodeIndex(int setter); + public native int m_useQuantization(); public native b3QuantizedBvhDoubleData m_useQuantization(int setter); + public native int m_numContiguousLeafNodes(); public native b3QuantizedBvhDoubleData m_numContiguousLeafNodes(int setter); + public native int m_numQuantizedContiguousNodes(); public native b3QuantizedBvhDoubleData m_numQuantizedContiguousNodes(int setter); + public native b3OptimizedBvhNodeDoubleData m_contiguousNodesPtr(); public native b3QuantizedBvhDoubleData m_contiguousNodesPtr(b3OptimizedBvhNodeDoubleData setter); + public native b3QuantizedBvhNodeData m_quantizedContiguousNodesPtr(); public native b3QuantizedBvhDoubleData m_quantizedContiguousNodesPtr(b3QuantizedBvhNodeData setter); + + public native int m_traversalMode(); public native b3QuantizedBvhDoubleData m_traversalMode(int setter); + public native int m_numSubtreeHeaders(); public native b3QuantizedBvhDoubleData m_numSubtreeHeaders(int setter); + public native b3BvhSubtreeInfoData m_subTreeInfoPtr(); public native b3QuantizedBvhDoubleData m_subTreeInfoPtr(b3BvhSubtreeInfoData setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java new file mode 100644 index 00000000000..88252fc686a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3QuantizedBvhFloatData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3QuantizedBvhFloatData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3QuantizedBvhFloatData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3QuantizedBvhFloatData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3QuantizedBvhFloatData position(long position) { + return (b3QuantizedBvhFloatData)super.position(position); + } + @Override public b3QuantizedBvhFloatData getPointer(long i) { + return new b3QuantizedBvhFloatData((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3FloatData m_bvhAabbMin(); public native b3QuantizedBvhFloatData m_bvhAabbMin(b3Vector3FloatData setter); + public native @ByRef b3Vector3FloatData m_bvhAabbMax(); public native b3QuantizedBvhFloatData m_bvhAabbMax(b3Vector3FloatData setter); + public native @ByRef b3Vector3FloatData m_bvhQuantization(); public native b3QuantizedBvhFloatData m_bvhQuantization(b3Vector3FloatData setter); + public native int m_curNodeIndex(); public native b3QuantizedBvhFloatData m_curNodeIndex(int setter); + public native int m_useQuantization(); public native b3QuantizedBvhFloatData m_useQuantization(int setter); + public native int m_numContiguousLeafNodes(); public native b3QuantizedBvhFloatData m_numContiguousLeafNodes(int setter); + public native int m_numQuantizedContiguousNodes(); public native b3QuantizedBvhFloatData m_numQuantizedContiguousNodes(int setter); + public native b3OptimizedBvhNodeFloatData m_contiguousNodesPtr(); public native b3QuantizedBvhFloatData m_contiguousNodesPtr(b3OptimizedBvhNodeFloatData setter); + public native b3QuantizedBvhNodeData m_quantizedContiguousNodesPtr(); public native b3QuantizedBvhFloatData m_quantizedContiguousNodesPtr(b3QuantizedBvhNodeData setter); + public native b3BvhSubtreeInfoData m_subTreeInfoPtr(); public native b3QuantizedBvhFloatData m_subTreeInfoPtr(b3BvhSubtreeInfoData setter); + public native int m_traversalMode(); public native b3QuantizedBvhFloatData m_traversalMode(int setter); + public native int m_numSubtreeHeaders(); public native b3QuantizedBvhFloatData m_numSubtreeHeaders(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java new file mode 100644 index 00000000000..7bb1187a251 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java @@ -0,0 +1,45 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**b3QuantizedBvhNode is a compressed aabb node, 16 bytes. + * Node can be used for leafnode or internal node. Leafnodes can point to 32-bit triangle index (non-negative range). */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3QuantizedBvhNode extends b3QuantizedBvhNodeData { + static { Loader.load(); } + /** Default native constructor. */ + public b3QuantizedBvhNode() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3QuantizedBvhNode(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3QuantizedBvhNode(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3QuantizedBvhNode position(long position) { + return (b3QuantizedBvhNode)super.position(position); + } + @Override public b3QuantizedBvhNode getPointer(long i) { + return new b3QuantizedBvhNode((Pointer)this).offsetAddress(i); + } + + + public native @Cast("bool") boolean isLeafNode(); + public native int getEscapeIndex(); + public native int getTriangleIndex(); + public native int getPartId(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java new file mode 100644 index 00000000000..254bca99533 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3QuantizedBvhNodeArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3QuantizedBvhNodeArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3QuantizedBvhNodeArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3QuantizedBvhNodeArray position(long position) { + return (b3QuantizedBvhNodeArray)super.position(position); + } + @Override public b3QuantizedBvhNodeArray getPointer(long i) { + return new b3QuantizedBvhNodeArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3QuantizedBvhNodeArray put(@Const @ByRef b3QuantizedBvhNodeArray other); + public b3QuantizedBvhNodeArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3QuantizedBvhNodeArray(@Const @ByRef b3QuantizedBvhNodeArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3QuantizedBvhNodeArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3QuantizedBvhNode at(int n); + + public native @ByRef @Name("operator []") b3QuantizedBvhNode get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3QuantizedBvhNode()") b3QuantizedBvhNode fillData); + public native void resize(int newsize); + public native @ByRef b3QuantizedBvhNode expandNonInitializing(); + + public native @ByRef b3QuantizedBvhNode expand(@Const @ByRef(nullValue = "b3QuantizedBvhNode()") b3QuantizedBvhNode fillValue); + public native @ByRef b3QuantizedBvhNode expand(); + + public native void push_back(@Const @ByRef b3QuantizedBvhNode _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3QuantizedBvhNodeArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java new file mode 100644 index 00000000000..bff14e80813 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3QuantizedBvhNodeOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3QuantizedBvhNodeOCLArray(Pointer p) { super(p); } + + public b3QuantizedBvhNodeOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3QuantizedBvhNodeOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3QuantizedBvhNode _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3QuantizedBvhNode _Val); + + public native @ByVal b3QuantizedBvhNode forcedAt(@Cast("size_t") long n); + + public native @ByVal b3QuantizedBvhNode at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3QuantizedBvhNodeArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3QuantizedBvhNodeArray srcArray); + + public native void copyFromHostPointer(@Const b3QuantizedBvhNode src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3QuantizedBvhNode src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3QuantizedBvhNodeArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3QuantizedBvhNodeArray destArray); + + public native void copyToHostPointer(b3QuantizedBvhNode destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3QuantizedBvhNode destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3QuantizedBvhNodeOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java new file mode 100644 index 00000000000..bcd8089a7ce --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java @@ -0,0 +1,80 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3RadixSort32CL extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RadixSort32CL(Pointer p) { super(p); } + + public static class b3ConstData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ConstData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ConstData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ConstData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ConstData position(long position) { + return (b3ConstData)super.position(position); + } + @Override public b3ConstData getPointer(long i) { + return new b3ConstData((Pointer)this).offsetAddress(i); + } + + public native int m_n(); public native b3ConstData m_n(int setter); + public native int m_nWGs(); public native b3ConstData m_nWGs(int setter); + public native int m_startBit(); public native b3ConstData m_startBit(int setter); + public native int m_nBlocksPerWG(); public native b3ConstData m_nBlocksPerWG(int setter); + } + /** enum b3RadixSort32CL:: */ + public static final int + DATA_ALIGNMENT = 256, + WG_SIZE = 64, + BLOCK_SIZE = 256, + ELEMENTS_PER_WORK_ITEM = (BLOCK_SIZE / WG_SIZE), + BITS_PER_PASS = 4, + NUM_BUCKET = (1 << BITS_PER_PASS), + // if you change this, change nPerWI in kernel as well + NUM_WGS = 20 * 6; // cypress + // NUM_WGS = 24*6, // cayman + // NUM_WGS = 32*4, // nv + public b3RadixSort32CL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int initialCapacity/*=0*/) { super((Pointer)null); allocate(ctx, device, queue, initialCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int initialCapacity/*=0*/); + public b3RadixSort32CL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, device, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + + public native void execute(@ByRef b3UnsignedIntOCLArray keysIn, @ByRef b3UnsignedIntOCLArray keysOut, @ByRef b3UnsignedIntOCLArray valuesIn, + @ByRef b3UnsignedIntOCLArray valuesOut, int n, int sortBits/*=32*/); + public native void execute(@ByRef b3UnsignedIntOCLArray keysIn, @ByRef b3UnsignedIntOCLArray keysOut, @ByRef b3UnsignedIntOCLArray valuesIn, + @ByRef b3UnsignedIntOCLArray valuesOut, int n); + + /**keys only */ + public native void execute(@ByRef b3UnsignedIntOCLArray keysInOut, int sortBits/*=32*/); + public native void execute(@ByRef b3UnsignedIntOCLArray keysInOut); + + public native void execute(@ByRef b3SortDataOCLArray keyValuesInOut, int sortBits/*=32*/); + public native void execute(@ByRef b3SortDataOCLArray keyValuesInOut); + public native void executeHost(@ByRef b3SortDataOCLArray keyValuesInOut, int sortBits/*=32*/); + public native void executeHost(@ByRef b3SortDataOCLArray keyValuesInOut); + public native void executeHost(@ByRef b3SortDataArray keyValuesInOut, int sortBits/*=32*/); + public native void executeHost(@ByRef b3SortDataArray keyValuesInOut); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java new file mode 100644 index 00000000000..db17380d4fc --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3RayInfoOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RayInfoOCLArray(Pointer p) { super(p); } + + public b3RayInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3RayInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3RayInfo _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3RayInfo _Val); + + public native @ByVal b3RayInfo forcedAt(@Cast("size_t") long n); + + public native @ByVal b3RayInfo at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3RayInfoArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3RayInfoArray srcArray); + + public native void copyFromHostPointer(@Const b3RayInfo src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3RayInfo src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3RayInfoArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3RayInfoArray destArray); + + public native void copyToHostPointer(b3RayInfo destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3RayInfo destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3RayInfoOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java new file mode 100644 index 00000000000..730f1dfa9a9 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3RigidBodyDataOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3RigidBodyDataOCLArray(Pointer p) { super(p); } + + public b3RigidBodyDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3RigidBodyDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3RigidBodyData _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3RigidBodyData _Val); + + public native @ByVal b3RigidBodyData forcedAt(@Cast("size_t") long n); + + public native @ByVal b3RigidBodyData at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3RigidBodyDataArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3RigidBodyDataArray srcArray); + + public native void copyFromHostPointer(@Const b3RigidBodyData src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3RigidBodyData src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3RigidBodyDataArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3RigidBodyDataArray destArray); + + public native void copyToHostPointer(b3RigidBodyData destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3RigidBodyData destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3RigidBodyDataOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java new file mode 100644 index 00000000000..6ad6332d99e --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java @@ -0,0 +1,27 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**just make sure that the b3Aabb is 16-byte aligned */ +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3SapAabb extends b3Aabb { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3SapAabb() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SapAabb(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java new file mode 100644 index 00000000000..6f734a6de5a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3SapAabbArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SapAabbArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3SapAabbArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3SapAabbArray position(long position) { + return (b3SapAabbArray)super.position(position); + } + @Override public b3SapAabbArray getPointer(long i) { + return new b3SapAabbArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3SapAabbArray put(@Const @ByRef b3SapAabbArray other); + public b3SapAabbArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3SapAabbArray(@Const @ByRef b3SapAabbArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3SapAabbArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3SapAabb at(int n); + + public native @ByRef @Name("operator []") b3SapAabb get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3SapAabb()") b3SapAabb fillData); + public native void resize(int newsize); + public native @ByRef b3SapAabb expandNonInitializing(); + + public native @ByRef b3SapAabb expand(@Const @ByRef(nullValue = "b3SapAabb()") b3SapAabb fillValue); + public native @ByRef b3SapAabb expand(); + + public native void push_back(@Const @ByRef b3SapAabb _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3SapAabbArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java new file mode 100644 index 00000000000..a9fae43149a --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3SapAabbOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SapAabbOCLArray(Pointer p) { super(p); } + + public b3SapAabbOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3SapAabbOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3SapAabb _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3SapAabb _Val); + + public native @ByVal b3SapAabb forcedAt(@Cast("size_t") long n); + + public native @ByVal b3SapAabb at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3SapAabbArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3SapAabbArray srcArray); + + public native void copyFromHostPointer(@Const b3SapAabb src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3SapAabb src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3SapAabbArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3SapAabbArray destArray); + + public native void copyToHostPointer(b3SapAabb destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3SapAabb destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3SapAabbOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java new file mode 100644 index 00000000000..8bc7b76f734 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java @@ -0,0 +1,26 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Opaque @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3Serializer extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public b3Serializer() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Serializer(Pointer p) { super(p); } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java new file mode 100644 index 00000000000..a2fce1064b3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java @@ -0,0 +1,41 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3ShortIntIndexData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ShortIntIndexData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ShortIntIndexData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ShortIntIndexData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ShortIntIndexData position(long position) { + return (b3ShortIntIndexData)super.position(position); + } + @Override public b3ShortIntIndexData getPointer(long i) { + return new b3ShortIntIndexData((Pointer)this).offsetAddress(i); + } + + public native short m_value(); public native b3ShortIntIndexData m_value(short setter); + public native @Cast("char") byte m_pad(int i); public native b3ShortIntIndexData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java new file mode 100644 index 00000000000..14dc32dccc7 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3ShortIntIndexTripletData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3ShortIntIndexTripletData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3ShortIntIndexTripletData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3ShortIntIndexTripletData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3ShortIntIndexTripletData position(long position) { + return (b3ShortIntIndexTripletData)super.position(position); + } + @Override public b3ShortIntIndexTripletData getPointer(long i) { + return new b3ShortIntIndexTripletData((Pointer)this).offsetAddress(i); + } + + public native short m_values(int i); public native b3ShortIntIndexTripletData m_values(int i, short setter); + @MemberGetter public native ShortPointer m_values(); + public native @Cast("char") byte m_pad(int i); public native b3ShortIntIndexTripletData m_pad(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_pad(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java new file mode 100644 index 00000000000..7ac78f7e561 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java @@ -0,0 +1,70 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3Solver extends b3SolverBase { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Solver(Pointer p) { super(p); } + + public native @ByRef cl_context m_context(); public native b3Solver m_context(cl_context setter); + public native @ByRef cl_device_id m_device(); public native b3Solver m_device(cl_device_id setter); + public native @ByRef cl_command_queue m_queue(); public native b3Solver m_queue(cl_command_queue setter); + + public native b3UnsignedIntOCLArray m_numConstraints(); public native b3Solver m_numConstraints(b3UnsignedIntOCLArray setter); + public native b3UnsignedIntOCLArray m_offsets(); public native b3Solver m_offsets(b3UnsignedIntOCLArray setter); + + + public native int m_nIterations(); public native b3Solver m_nIterations(int setter); + public native @ByRef cl_kernel m_batchingKernel(); public native b3Solver m_batchingKernel(cl_kernel setter); + public native @ByRef cl_kernel m_batchingKernelNew(); public native b3Solver m_batchingKernelNew(cl_kernel setter); + public native @ByRef cl_kernel m_solveContactKernel(); public native b3Solver m_solveContactKernel(cl_kernel setter); + public native @ByRef cl_kernel m_solveFrictionKernel(); public native b3Solver m_solveFrictionKernel(cl_kernel setter); + public native @ByRef cl_kernel m_contactToConstraintKernel(); public native b3Solver m_contactToConstraintKernel(cl_kernel setter); + public native @ByRef cl_kernel m_setSortDataKernel(); public native b3Solver m_setSortDataKernel(cl_kernel setter); + public native @ByRef cl_kernel m_reorderContactKernel(); public native b3Solver m_reorderContactKernel(cl_kernel setter); + public native @ByRef cl_kernel m_copyConstraintKernel(); public native b3Solver m_copyConstraintKernel(cl_kernel setter); + + public native b3RadixSort32CL m_sort32(); public native b3Solver m_sort32(b3RadixSort32CL setter); + public native b3BoundSearchCL m_search(); public native b3Solver m_search(b3BoundSearchCL setter); + + + public native b3SortDataOCLArray m_sortDataBuffer(); public native b3Solver m_sortDataBuffer(b3SortDataOCLArray setter); + public native b3Contact4OCLArray m_contactBuffer2(); public native b3Solver m_contactBuffer2(b3Contact4OCLArray setter); + + /** enum b3Solver:: */ + public static final int + DYNAMIC_CONTACT_ALLOCATION_THRESHOLD = 2000000; + + public b3Solver(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int pairCapacity) { super((Pointer)null); allocate(ctx, device, queue, pairCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int pairCapacity); + + public native void solveContactConstraint(@Const b3RigidBodyDataOCLArray bodyBuf, @Const b3InertiaDataOCLArray inertiaBuf, + b3GpuConstraint4OCLArray constraint, Pointer additionalData, int n, int maxNumBatches); + + public native void solveContactConstraintHost(b3RigidBodyDataOCLArray bodyBuf, b3InertiaDataOCLArray shapeBuf, + b3GpuConstraint4OCLArray constraint, Pointer additionalData, int n, int maxNumBatches, b3IntArray batchSizes); + + public native void convertToConstraints(@Const b3RigidBodyDataOCLArray bodyBuf, + @Const b3InertiaDataOCLArray shapeBuf, + b3Contact4OCLArray contactsIn, b3GpuConstraint4OCLArray contactCOut, Pointer additionalData, + int nContacts, @Const @ByRef ConstraintCfg cfg); + + public native void batchContacts(b3Contact4OCLArray contacts, int nContacts, b3UnsignedIntOCLArray n, b3UnsignedIntOCLArray offsets, int staticIdx); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java new file mode 100644 index 00000000000..e3f9e779305 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java @@ -0,0 +1,55 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3SolverBase extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3SolverBase() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3SolverBase(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SolverBase(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3SolverBase position(long position) { + return (b3SolverBase)super.position(position); + } + @Override public b3SolverBase getPointer(long i) { + return new b3SolverBase((Pointer)this).offsetAddress(i); + } + + @NoOffset public static class ConstraintCfg extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public ConstraintCfg(Pointer p) { super(p); } + + public ConstraintCfg(float dt/*=0.f*/) { super((Pointer)null); allocate(dt); } + private native void allocate(float dt/*=0.f*/); + public ConstraintCfg() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native float m_positionDrift(); public native ConstraintCfg m_positionDrift(float setter); + public native float m_positionConstraintCoeff(); public native ConstraintCfg m_positionConstraintCoeff(float setter); + public native float m_dt(); public native ConstraintCfg m_dt(float setter); + public native @Cast("bool") boolean m_enableParallelSolve(); public native ConstraintCfg m_enableParallelSolve(boolean setter); + public native float m_batchCellSize(); public native ConstraintCfg m_batchCellSize(float setter); + public native int m_staticIdx(); public native ConstraintCfg m_staticIdx(int setter); + } +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java new file mode 100644 index 00000000000..48d1181289d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java @@ -0,0 +1,42 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3SortData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3SortData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3SortData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SortData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3SortData position(long position) { + return (b3SortData)super.position(position); + } + @Override public b3SortData getPointer(long i) { + return new b3SortData((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int m_key(); public native b3SortData m_key(int setter); + public native @Cast("unsigned int") int x(); public native b3SortData x(int setter); + public native @Cast("unsigned int") int m_value(); public native b3SortData m_value(int setter); + public native @Cast("unsigned int") int y(); public native b3SortData y(int setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java new file mode 100644 index 00000000000..46d4a9e6c02 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3SortDataArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SortDataArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3SortDataArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3SortDataArray position(long position) { + return (b3SortDataArray)super.position(position); + } + @Override public b3SortDataArray getPointer(long i) { + return new b3SortDataArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3SortDataArray put(@Const @ByRef b3SortDataArray other); + public b3SortDataArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3SortDataArray(@Const @ByRef b3SortDataArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3SortDataArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByRef b3SortData at(int n); + + public native @ByRef @Name("operator []") b3SortData get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @Const @ByRef(nullValue = "b3SortData()") b3SortData fillData); + public native void resize(int newsize); + public native @ByRef b3SortData expandNonInitializing(); + + public native @ByRef b3SortData expand(@Const @ByRef(nullValue = "b3SortData()") b3SortData fillValue); + public native @ByRef b3SortData expand(); + + public native void push_back(@Const @ByRef b3SortData _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + + + + + + + + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3SortDataArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java new file mode 100644 index 00000000000..ccff62a567c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3SortDataOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SortDataOCLArray(Pointer p) { super(p); } + + public b3SortDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3SortDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3SortData _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3SortData _Val); + + public native @ByVal b3SortData forcedAt(@Cast("size_t") long n); + + public native @ByVal b3SortData at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3SortDataArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3SortDataArray srcArray); + + public native void copyFromHostPointer(@Const b3SortData src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3SortData src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3SortDataArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3SortDataArray destArray); + + public native void copyToHostPointer(b3SortData destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3SortData destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3SortDataOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java new file mode 100644 index 00000000000..1f576b7fe2c --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java @@ -0,0 +1,80 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/** The b3StridingMeshInterface is the interface class for high performance generic access to triangle meshes, used in combination with b3BvhTriangleMeshShape and some other collision shapes. + * Using index striding of 3*sizeof(integer) it can use triangle arrays, using index striding of 1*sizeof(integer) it can handle triangle strips. + * It allows for sharing graphics and collision meshes. Also it provides locking/unlocking of graphics meshes that are in gpu memory. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3StridingMeshInterface extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3StridingMeshInterface(Pointer p) { super(p); } + + + public native void InternalProcessAllTriangles(b3InternalTriangleIndexCallback callback, @Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax); + + /**brute force method to calculate aabb */ + public native void calculateAabbBruteForce(@ByRef b3Vector3 aabbMin, @ByRef b3Vector3 aabbMax); + + /** get read and write access to a subpart of a triangle mesh + * this subpart has a continuous array of vertices and indices + * in this way the mesh can be handled as chunks of memory with striding + * very similar to OpenGL vertexarray support + * make a call to unLockVertexBase when the read and write access is finished */ + public native void getLockedVertexIndexBase(@Cast("unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer stride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer stride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] stride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + /** unLockVertexBase finishes the access to a subpart of the triangle mesh + * make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished */ + public native void unLockVertexBase(int subpart); + + public native void unLockReadOnlyVertexBase(int subpart); + + /** getNumSubParts returns the number of separate subparts + * each subpart has a continuous array of vertices and indices */ + public native int getNumSubParts(); + + public native void preallocateVertices(int numverts); + public native void preallocateIndices(int numindices); + + public native @Cast("bool") boolean hasPremadeAabb(); + public native void setPremadeAabb(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax); + public native void getPremadeAabb(b3Vector3 aabbMin, b3Vector3 aabbMax); + + public native @Const @ByRef b3Vector3 getScaling(); + public native void setScaling(@Const @ByRef b3Vector3 scaling); + + public native int calculateSerializeBufferSize(); + + /**fills the dataBuffer and returns the struct name (and 0 on failure) */ + //virtual const char* serialize(void* dataBuffer, b3Serializer* serializer) const; +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java new file mode 100644 index 00000000000..86970b32584 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java @@ -0,0 +1,44 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64 */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3StridingMeshInterfaceData extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3StridingMeshInterfaceData() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3StridingMeshInterfaceData(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3StridingMeshInterfaceData(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3StridingMeshInterfaceData position(long position) { + return (b3StridingMeshInterfaceData)super.position(position); + } + @Override public b3StridingMeshInterfaceData getPointer(long i) { + return new b3StridingMeshInterfaceData((Pointer)this).offsetAddress(i); + } + + public native b3MeshPartData m_meshPartsPtr(); public native b3StridingMeshInterfaceData m_meshPartsPtr(b3MeshPartData setter); + public native @ByRef b3Vector3FloatData m_scaling(); public native b3StridingMeshInterfaceData m_scaling(b3Vector3FloatData setter); + public native int m_numMeshParts(); public native b3StridingMeshInterfaceData m_numMeshParts(int setter); + public native @Cast("char") byte m_padding(int i); public native b3StridingMeshInterfaceData m_padding(int i, byte setter); + @MemberGetter public native @Cast("char*") BytePointer m_padding(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java new file mode 100644 index 00000000000..1ebf3a288fa --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java @@ -0,0 +1,51 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3SubSimplexClosestResult extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public b3SubSimplexClosestResult() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3SubSimplexClosestResult(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3SubSimplexClosestResult(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public b3SubSimplexClosestResult position(long position) { + return (b3SubSimplexClosestResult)super.position(position); + } + @Override public b3SubSimplexClosestResult getPointer(long i) { + return new b3SubSimplexClosestResult((Pointer)this).offsetAddress(i); + } + + public native @ByRef b3Vector3 m_closestPointOnSimplex(); public native b3SubSimplexClosestResult m_closestPointOnSimplex(b3Vector3 setter); + //MASK for m_usedVertices + //stores the simplex vertex-usage, using the MASK, + // if m_usedVertices & MASK then the related vertex is used + public native @ByRef b3UsageBitfield m_usedVertices(); public native b3SubSimplexClosestResult m_usedVertices(b3UsageBitfield setter); + public native @Cast("b3Scalar") float m_barycentricCoords(int i); public native b3SubSimplexClosestResult m_barycentricCoords(int i, float setter); + @MemberGetter public native @Cast("b3Scalar*") FloatPointer m_barycentricCoords(); + public native @Cast("bool") boolean m_degenerate(); public native b3SubSimplexClosestResult m_degenerate(boolean setter); + + public native void reset(); + public native @Cast("bool") boolean isValid(); + public native void setBarycentricCoordinates(@Cast("b3Scalar") float a/*=b3Scalar(0.)*/, @Cast("b3Scalar") float b/*=b3Scalar(0.)*/, @Cast("b3Scalar") float c/*=b3Scalar(0.)*/, @Cast("b3Scalar") float d/*=b3Scalar(0.)*/); + public native void setBarycentricCoordinates(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java new file mode 100644 index 00000000000..e2163f1d81d --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java @@ -0,0 +1,29 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**The b3TriangleCallback provides a callback for each overlapping triangle when calling processAllTriangles. + * This callback is called by processAllTriangles for all b3ConcaveShape derived class, such as b3BvhTriangleMeshShape, b3StaticPlaneShape and b3HeightfieldTerrainShape. */ +@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3TriangleCallback extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TriangleCallback(Pointer p) { super(p); } + + public native void processTriangle(b3Vector3 triangle, int partId, int triangleIndex); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java new file mode 100644 index 00000000000..4bf92dc2716 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java @@ -0,0 +1,88 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/**The b3TriangleIndexVertexArray allows to access multiple triangle meshes, by indexing into existing triangle/index arrays. + * Additional meshes can be added using addIndexedMesh + * No duplcate is made of the vertex/index data, it only indexes into external vertex/index arrays. + * So keep those arrays around during the lifetime of this b3TriangleIndexVertexArray. */ +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3TriangleIndexVertexArray extends b3StridingMeshInterface { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TriangleIndexVertexArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3TriangleIndexVertexArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3TriangleIndexVertexArray position(long position) { + return (b3TriangleIndexVertexArray)super.position(position); + } + @Override public b3TriangleIndexVertexArray getPointer(long i) { + return new b3TriangleIndexVertexArray((Pointer)this).offsetAddress(i); + } + + + public b3TriangleIndexVertexArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + //just to be backwards compatible + public b3TriangleIndexVertexArray(int numTriangles, IntPointer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("b3Scalar*") FloatPointer vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, IntPointer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("b3Scalar*") FloatPointer vertexBase, int vertexStride); + public b3TriangleIndexVertexArray(int numTriangles, IntBuffer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("b3Scalar*") FloatBuffer vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, IntBuffer triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("b3Scalar*") FloatBuffer vertexBase, int vertexStride); + public b3TriangleIndexVertexArray(int numTriangles, int[] triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("b3Scalar*") float[] vertexBase, int vertexStride) { super((Pointer)null); allocate(numTriangles, triangleIndexBase, triangleIndexStride, numVertices, vertexBase, vertexStride); } + private native void allocate(int numTriangles, int[] triangleIndexBase, int triangleIndexStride, int numVertices, @Cast("b3Scalar*") float[] vertexBase, int vertexStride); + + public native void addIndexedMesh(@Const @ByRef b3IndexedMesh mesh, @Cast("PHY_ScalarType") int indexType/*=PHY_INTEGER*/); + public native void addIndexedMesh(@Const @ByRef b3IndexedMesh mesh); + + public native void getLockedVertexIndexBase(@Cast("unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedVertexIndexBase(@Cast("unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") PointerPointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") PointerPointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr BytePointer vertexbase, @ByRef IntPointer numverts, @Cast("PHY_ScalarType*") @ByRef IntPointer type, @ByRef IntPointer vertexStride, @Cast("const unsigned char**") @ByPtrPtr BytePointer indexbase, @ByRef IntPointer indexstride, @ByRef IntPointer numfaces, @Cast("PHY_ScalarType*") @ByRef IntPointer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr ByteBuffer vertexbase, @ByRef IntBuffer numverts, @Cast("PHY_ScalarType*") @ByRef IntBuffer type, @ByRef IntBuffer vertexStride, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer indexbase, @ByRef IntBuffer indexstride, @ByRef IntBuffer numfaces, @Cast("PHY_ScalarType*") @ByRef IntBuffer indicestype); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype, int subpart/*=0*/); + public native void getLockedReadOnlyVertexIndexBase(@Cast("const unsigned char**") @ByPtrPtr byte[] vertexbase, @ByRef int[] numverts, @Cast("PHY_ScalarType*") @ByRef int[] type, @ByRef int[] vertexStride, @Cast("const unsigned char**") @ByPtrPtr byte[] indexbase, @ByRef int[] indexstride, @ByRef int[] numfaces, @Cast("PHY_ScalarType*") @ByRef int[] indicestype); + + /** unLockVertexBase finishes the access to a subpart of the triangle mesh + * make a call to unLockVertexBase when the read and write access (using getLockedVertexIndexBase) is finished */ + public native void unLockVertexBase(int subpart); + + public native void unLockReadOnlyVertexBase(int subpart); + + /** getNumSubParts returns the number of separate subparts + * each subpart has a continuous array of vertices and indices */ + public native int getNumSubParts(); + + public native @Cast("IndexedMeshArray*") @ByRef b3ConvexUtilityArray getIndexedMeshArray(); + + public native void preallocateVertices(int numverts); + public native void preallocateIndices(int numindices); + + public native @Cast("bool") boolean hasPremadeAabb(); + public native void setPremadeAabb(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax); + public native void getPremadeAabb(b3Vector3 aabbMin, b3Vector3 aabbMax); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java new file mode 100644 index 00000000000..d4c2958aa00 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3TriangleIndexVertexArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3TriangleIndexVertexArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3TriangleIndexVertexArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3TriangleIndexVertexArrayArray position(long position) { + return (b3TriangleIndexVertexArrayArray)super.position(position); + } + @Override public b3TriangleIndexVertexArrayArray getPointer(long i) { + return new b3TriangleIndexVertexArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3TriangleIndexVertexArrayArray put(@Const @ByRef b3TriangleIndexVertexArrayArray other); + public b3TriangleIndexVertexArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3TriangleIndexVertexArrayArray(@Const @ByRef b3TriangleIndexVertexArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3TriangleIndexVertexArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef b3TriangleIndexVertexArray at(int n); + + public native @ByPtrRef @Name("operator []") b3TriangleIndexVertexArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef b3TriangleIndexVertexArray fillData/*=b3TriangleIndexVertexArray*()*/); + public native void resize(int newsize); + public native @ByPtrRef b3TriangleIndexVertexArray expandNonInitializing(); + + public native @ByPtrRef b3TriangleIndexVertexArray expand(@ByPtrRef b3TriangleIndexVertexArray fillValue/*=b3TriangleIndexVertexArray*()*/); + public native @ByPtrRef b3TriangleIndexVertexArray expand(); + + public native void push_back(@ByPtrRef b3TriangleIndexVertexArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef b3TriangleIndexVertexArray key); + + public native int findLinearSearch(@ByPtrRef b3TriangleIndexVertexArray key); + + public native int findLinearSearch2(@ByPtrRef b3TriangleIndexVertexArray key); + + public native void remove(@ByPtrRef b3TriangleIndexVertexArray key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3TriangleIndexVertexArrayArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java new file mode 100644 index 00000000000..c5e2b7b7b40 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java @@ -0,0 +1,84 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3UnsignedCharOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3UnsignedCharOCLArray(Pointer p) { super(p); } + + public b3UnsignedCharOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3UnsignedCharOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Cast("const unsigned char") byte _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Cast("const unsigned char") byte _Val); + + public native @Cast("unsigned char") byte forcedAt(@Cast("size_t") long n); + + public native @Cast("unsigned char") byte at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3UnsignedCharArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3UnsignedCharArray srcArray); + + public native void copyFromHostPointer(@Cast("const unsigned char*") BytePointer src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Cast("const unsigned char*") BytePointer src, @Cast("size_t") long numElems); + public native void copyFromHostPointer(@Cast("const unsigned char*") ByteBuffer src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Cast("const unsigned char*") ByteBuffer src, @Cast("size_t") long numElems); + public native void copyFromHostPointer(@Cast("const unsigned char*") byte[] src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Cast("const unsigned char*") byte[] src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3UnsignedCharArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3UnsignedCharArray destArray); + + public native void copyToHostPointer(@Cast("unsigned char*") BytePointer destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(@Cast("unsigned char*") BytePointer destPtr, @Cast("size_t") long numElem); + public native void copyToHostPointer(@Cast("unsigned char*") ByteBuffer destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(@Cast("unsigned char*") ByteBuffer destPtr, @Cast("size_t") long numElem); + public native void copyToHostPointer(@Cast("unsigned char*") byte[] destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(@Cast("unsigned char*") byte[] destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3UnsignedCharOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java new file mode 100644 index 00000000000..4ab245c1822 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java @@ -0,0 +1,91 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + +@Name("b3AlignedObjectArray*>") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3UnsignedCharOCLArrayArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3UnsignedCharOCLArrayArray(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3UnsignedCharOCLArrayArray(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3UnsignedCharOCLArrayArray position(long position) { + return (b3UnsignedCharOCLArrayArray)super.position(position); + } + @Override public b3UnsignedCharOCLArrayArray getPointer(long i) { + return new b3UnsignedCharOCLArrayArray((Pointer)this).offsetAddress(i); + } + + public native @ByRef @Name("operator =") b3UnsignedCharOCLArrayArray put(@Const @ByRef b3UnsignedCharOCLArrayArray other); + public b3UnsignedCharOCLArrayArray() { super((Pointer)null); allocate(); } + private native void allocate(); + + /**Generally it is best to avoid using the copy constructor of an b3AlignedObjectArray, and use a (const) reference to the array instead. */ + public b3UnsignedCharOCLArrayArray(@Const @ByRef b3UnsignedCharOCLArrayArray otherArray) { super((Pointer)null); allocate(otherArray); } + private native void allocate(@Const @ByRef b3UnsignedCharOCLArrayArray otherArray); + + /** return the number of elements in the array */ + public native int size(); + + public native @ByPtrRef b3UnsignedCharOCLArray at(int n); + + public native @ByPtrRef @Name("operator []") b3UnsignedCharOCLArray get(int n); + + /**clear the array, deallocated memory. Generally it is better to use array.resize(0), to reduce performance overhead of run-time memory (de)allocations. */ + public native void clear(); + + public native void pop_back(); + + /**resize changes the number of elements in the array. If the new size is larger, the new elements will be constructed using the optional second argument. + * when the new number of elements is smaller, the destructor will be called, but memory will not be freed, to reduce performance overhead of run-time memory (de)allocations. */ + public native void resizeNoInitialize(int newsize); + + public native void resize(int newsize, @ByPtrRef b3UnsignedCharOCLArray fillData/*=b3OpenCLArray*()*/); + public native void resize(int newsize); + public native @ByPtrRef b3UnsignedCharOCLArray expandNonInitializing(); + + public native @ByPtrRef b3UnsignedCharOCLArray expand(@ByPtrRef b3UnsignedCharOCLArray fillValue/*=b3OpenCLArray*()*/); + public native @ByPtrRef b3UnsignedCharOCLArray expand(); + + public native void push_back(@ByPtrRef b3UnsignedCharOCLArray _Val); + + /** return the pre-allocated (reserved) elements, this is at least as large as the total number of elements,see size() and reserve() */ + public native @Name("capacity") int _capacity(); + + public native void reserve(int _Count); + + /**heap sort from http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Heap/ */ /*downHeap*/ + + public native void swap(int index0, int index1); + + /**non-recursive binary search, assumes sorted array */ + public native int findBinarySearch(@ByPtrRef b3UnsignedCharOCLArray key); + + public native int findLinearSearch(@ByPtrRef b3UnsignedCharOCLArray key); + + public native int findLinearSearch2(@ByPtrRef b3UnsignedCharOCLArray key); + + public native void remove(@ByPtrRef b3UnsignedCharOCLArray key); + + //PCK: whole function + public native void initializeFromBuffer(Pointer buffer, int size, int _capacity); + + public native void copyFromArray(@Const @ByRef b3UnsignedCharOCLArrayArray otherArray); + + public native void removeAtIndex(int index); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java new file mode 100644 index 00000000000..aed62aa8250 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java @@ -0,0 +1,84 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3UnsignedIntOCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3UnsignedIntOCLArray(Pointer p) { super(p); } + + public b3UnsignedIntOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3UnsignedIntOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Cast("const unsigned int") int _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Cast("const unsigned int") int _Val); + + public native @Cast("unsigned int") int forcedAt(@Cast("size_t") long n); + + public native @Cast("unsigned int") int at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3UnsignedIntArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3UnsignedIntArray srcArray); + + public native void copyFromHostPointer(@Cast("const unsigned int*") IntPointer src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Cast("const unsigned int*") IntPointer src, @Cast("size_t") long numElems); + public native void copyFromHostPointer(@Cast("const unsigned int*") IntBuffer src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Cast("const unsigned int*") IntBuffer src, @Cast("size_t") long numElems); + public native void copyFromHostPointer(@Cast("const unsigned int*") int[] src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Cast("const unsigned int*") int[] src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3UnsignedIntArray destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3UnsignedIntArray destArray); + + public native void copyToHostPointer(@Cast("unsigned int*") IntPointer destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(@Cast("unsigned int*") IntPointer destPtr, @Cast("size_t") long numElem); + public native void copyToHostPointer(@Cast("unsigned int*") IntBuffer destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(@Cast("unsigned int*") IntBuffer destPtr, @Cast("size_t") long numElem); + public native void copyToHostPointer(@Cast("unsigned int*") int[] destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(@Cast("unsigned int*") int[] destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3UnsignedIntOCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java new file mode 100644 index 00000000000..cee74872fb3 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java @@ -0,0 +1,47 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3UsageBitfield extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3UsageBitfield(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3UsageBitfield(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3UsageBitfield position(long position) { + return (b3UsageBitfield)super.position(position); + } + @Override public b3UsageBitfield getPointer(long i) { + return new b3UsageBitfield((Pointer)this).offsetAddress(i); + } + + public b3UsageBitfield() { super((Pointer)null); allocate(); } + private native void allocate(); + + public native void reset(); + public native @Cast("unsigned short") @NoOffset short usedVertexA(); public native b3UsageBitfield usedVertexA(short setter); + public native @Cast("unsigned short") @NoOffset short usedVertexB(); public native b3UsageBitfield usedVertexB(short setter); + public native @Cast("unsigned short") @NoOffset short usedVertexC(); public native b3UsageBitfield usedVertexC(short setter); + public native @Cast("unsigned short") @NoOffset short usedVertexD(); public native b3UsageBitfield usedVertexD(short setter); + public native @Cast("unsigned short") @NoOffset short unused1(); public native b3UsageBitfield unused1(short setter); + public native @Cast("unsigned short") @NoOffset short unused2(); public native b3UsageBitfield unused2(short setter); + public native @Cast("unsigned short") @NoOffset short unused3(); public native b3UsageBitfield unused3(short setter); + public native @Cast("unsigned short") @NoOffset short unused4(); public native b3UsageBitfield unused4(short setter); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java new file mode 100644 index 00000000000..f56b0611cea --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java @@ -0,0 +1,76 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +@Name("b3OpenCLArray") @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3Vector3OCLArray extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3Vector3OCLArray(Pointer p) { super(p); } + + public b3Vector3OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3Vector3OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + + /**this is an error-prone method with no error checking, be careful! */ + public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + + // we could enable this assignment, but need to make sure to avoid accidental deep copies + // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) + // { + // copyFromArray(src); + // return *this; + // } + + public native @ByVal cl_mem getBufferCL(); + + public native @Cast("bool") boolean push_back(@Const @ByRef b3Vector3 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); + public native @Cast("bool") boolean push_back(@Const @ByRef b3Vector3 _Val); + + public native @ByVal b3Vector3 forcedAt(@Cast("size_t") long n); + + public native @ByVal b3Vector3 at(@Cast("size_t") long n); + + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean resize(@Cast("size_t") long newsize); + + public native @Cast("size_t") long size(); + + public native @Cast("size_t") @Name("capacity") long _capacity(); + + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); + public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); + + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + + public native void copyFromHost(@Const @ByRef b3Vector3Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHost(@Const @ByRef b3Vector3Array srcArray); + + public native void copyFromHostPointer(@Const b3Vector3 src, @Cast("size_t") long numElems, @Cast("size_t") long destFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyFromHostPointer(@Const b3Vector3 src, @Cast("size_t") long numElems); + + public native void copyToHost(@ByRef b3Vector3Array destArray, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHost(@ByRef b3Vector3Array destArray); + + public native void copyToHostPointer(b3Vector3 destPtr, @Cast("size_t") long numElem, @Cast("size_t") long srcFirstElem/*=0*/, @Cast("bool") boolean waitForCompletion/*=true*/); + public native void copyToHostPointer(b3Vector3 destPtr, @Cast("size_t") long numElem); + + public native void copyFromOpenCLArray(@Const @ByRef b3Vector3OCLArray src); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java new file mode 100644 index 00000000000..95f8cdb5356 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java @@ -0,0 +1,94 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.Bullet3OpenCL; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +import static org.bytedeco.bullet.global.Bullet3OpenCL.*; + + +/** b3VoronoiSimplexSolver is an implementation of the closest point distance algorithm from a 1-4 points simplex to the origin. + * Can be used with GJK, as an alternative to Johnson distance algorithm. */ + +@NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) +public class b3VoronoiSimplexSolver extends Pointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public b3VoronoiSimplexSolver(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public b3VoronoiSimplexSolver(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public b3VoronoiSimplexSolver position(long position) { + return (b3VoronoiSimplexSolver)super.position(position); + } + @Override public b3VoronoiSimplexSolver getPointer(long i) { + return new b3VoronoiSimplexSolver((Pointer)this).offsetAddress(i); + } + + + public native int m_numVertices(); public native b3VoronoiSimplexSolver m_numVertices(int setter); + + public native @ByRef b3Vector3 m_simplexVectorW(int i); public native b3VoronoiSimplexSolver m_simplexVectorW(int i, b3Vector3 setter); + @MemberGetter public native b3Vector3 m_simplexVectorW(); + public native @ByRef b3Vector3 m_simplexPointsP(int i); public native b3VoronoiSimplexSolver m_simplexPointsP(int i, b3Vector3 setter); + @MemberGetter public native b3Vector3 m_simplexPointsP(); + public native @ByRef b3Vector3 m_simplexPointsQ(int i); public native b3VoronoiSimplexSolver m_simplexPointsQ(int i, b3Vector3 setter); + @MemberGetter public native b3Vector3 m_simplexPointsQ(); + + public native @ByRef b3Vector3 m_cachedP1(); public native b3VoronoiSimplexSolver m_cachedP1(b3Vector3 setter); + public native @ByRef b3Vector3 m_cachedP2(); public native b3VoronoiSimplexSolver m_cachedP2(b3Vector3 setter); + public native @ByRef b3Vector3 m_cachedV(); public native b3VoronoiSimplexSolver m_cachedV(b3Vector3 setter); + public native @ByRef b3Vector3 m_lastW(); public native b3VoronoiSimplexSolver m_lastW(b3Vector3 setter); + + public native @Cast("b3Scalar") float m_equalVertexThreshold(); public native b3VoronoiSimplexSolver m_equalVertexThreshold(float setter); + public native @Cast("bool") boolean m_cachedValidClosest(); public native b3VoronoiSimplexSolver m_cachedValidClosest(boolean setter); + + public native @ByRef b3SubSimplexClosestResult m_cachedBC(); public native b3VoronoiSimplexSolver m_cachedBC(b3SubSimplexClosestResult setter); + + public native @Cast("bool") boolean m_needsUpdate(); public native b3VoronoiSimplexSolver m_needsUpdate(boolean setter); + + public native void removeVertex(int index); + public native void reduceVertices(@Const @ByRef b3UsageBitfield usedVerts); + public native @Cast("bool") boolean updateClosestVectorAndPoints(); + + public native @Cast("bool") boolean closestPtPointTetrahedron(@Const @ByRef b3Vector3 p, @Const @ByRef b3Vector3 a, @Const @ByRef b3Vector3 b, @Const @ByRef b3Vector3 c, @Const @ByRef b3Vector3 d, @ByRef b3SubSimplexClosestResult finalResult); + public native int pointOutsideOfPlane(@Const @ByRef b3Vector3 p, @Const @ByRef b3Vector3 a, @Const @ByRef b3Vector3 b, @Const @ByRef b3Vector3 c, @Const @ByRef b3Vector3 d); + public native @Cast("bool") boolean closestPtPointTriangle(@Const @ByRef b3Vector3 p, @Const @ByRef b3Vector3 a, @Const @ByRef b3Vector3 b, @Const @ByRef b3Vector3 c, @ByRef b3SubSimplexClosestResult result); + public b3VoronoiSimplexSolver() { super((Pointer)null); allocate(); } + private native void allocate(); + public native void reset(); + + public native void addVertex(@Const @ByRef b3Vector3 w, @Const @ByRef b3Vector3 p, @Const @ByRef b3Vector3 q); + + public native void setEqualVertexThreshold(@Cast("b3Scalar") float threshold); + + public native @Cast("b3Scalar") float getEqualVertexThreshold(); + + public native @Cast("bool") boolean closest(@ByRef b3Vector3 v); + + public native @Cast("b3Scalar") float maxVertex(); + + public native @Cast("bool") boolean fullSimplex(); + + public native int getSimplex(b3Vector3 pBuf, b3Vector3 qBuf, b3Vector3 yBuf); + + public native @Cast("bool") boolean inSimplex(@Const @ByRef b3Vector3 w); + + public native void backup_closest(@ByRef b3Vector3 v); + + public native @Cast("bool") boolean emptySimplex(); + + public native void compute_points(@ByRef b3Vector3 p1, @ByRef b3Vector3 p2); + + public native int numVertices(); +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java index 012d9ac4fa1..5f518bdf0bb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java @@ -55,6 +55,12 @@ public class Bullet3Collision extends org.bytedeco.bullet.presets.Bullet3Collisi // #ifdef B3_USE_PLACEMENT_NEW // #include +// Targeting ../Bullet3Collision/sStkNNArray.java + + +// Targeting ../Bullet3Collision/sStkNPSArray.java + + // Targeting ../Bullet3Collision/b3AabbArray.java @@ -70,12 +76,6 @@ public class Bullet3Collision extends org.bytedeco.bullet.presets.Bullet3Collisi // Targeting ../Bullet3Collision/b3DbvtProxyArray.java -// Targeting ../Bullet3Collision/sStkNNArray.java - - -// Targeting ../Bullet3Collision/sStkNPSArray.java - - // Targeting ../Bullet3Collision/b3GpuChildShapeArray.java @@ -352,7 +352,7 @@ public static native void b3Merge(@Const @ByRef b3DbvtAabbMm a, -public static native @Cast("bool") @Name("operator ==") boolean equals(@Cast("const b3BroadphasePair*") @ByRef b3Int4 a, @Cast("const b3BroadphasePair*") @ByRef b3Int4 b); +public static native @Cast("bool") @Name("operator ==") boolean equals(@Const @ByRef b3Int4 a, @Const @ByRef b3Int4 b); // #endif //B3_OVERLAPPING_PAIR_H diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java index 92a04fe555e..53773b277e6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Common.java @@ -53,9 +53,21 @@ public class Bullet3Common extends org.bytedeco.bullet.presets.Bullet3Common { // #ifdef B3_USE_PLACEMENT_NEW // #include +// Targeting ../Bullet3Common/b3UnsignedCharArray.java + + // Targeting ../Bullet3Common/b3IntArray.java +// Targeting ../Bullet3Common/b3UnsignedIntArray.java + + +// Targeting ../Bullet3Common/b3FloatArray.java + + +// Targeting ../Bullet3Common/b3Int2Array.java + + // Targeting ../Bullet3Common/b3Int4Array.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java index e4335f6af6d..f9de9dfbe65 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java @@ -17,6 +17,53 @@ public class Bullet3Dynamics extends org.bytedeco.bullet.presets.Bullet3Dynamics { static { Loader.load(); } +// Parsed from Bullet3Common/b3AlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_OBJECT_ARRAY__ +// #define B3_OBJECT_ARRAY__ + +// #include "b3Scalar.h" // has definitions like B3_FORCE_INLINE +// #include "b3AlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable B3_USE_PLACEMENT_NEW + * then the b3AlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable B3_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int B3_USE_PLACEMENT_NEW = 1; +//#define B3_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define B3_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef B3_USE_MEMCPY +// #include +// #include +// #endif //B3_USE_MEMCPY + +// #ifdef B3_USE_PLACEMENT_NEW +// #include +// Targeting ../Bullet3Dynamics/b3TypedConstraintArray.java + + + +// #endif //B3_OBJECT_ARRAY__ + + // Parsed from Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h /* diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java new file mode 100644 index 00000000000..062b44487f6 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java @@ -0,0 +1,1378 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet.global; + +import org.bytedeco.bullet.Bullet3OpenCL.*; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; +import org.bytedeco.bullet.Bullet3Common.*; +import static org.bytedeco.bullet.global.Bullet3Common.*; +import org.bytedeco.bullet.Bullet3Collision.*; +import static org.bytedeco.bullet.global.Bullet3Collision.*; +import org.bytedeco.bullet.Bullet3Dynamics.*; +import static org.bytedeco.bullet.global.Bullet3Dynamics.*; + +public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL { + static { Loader.load(); } + +// Parsed from Bullet3Common/b3AlignedObjectArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_OBJECT_ARRAY__ +// #define B3_OBJECT_ARRAY__ + +// #include "b3Scalar.h" // has definitions like B3_FORCE_INLINE +// #include "b3AlignedAllocator.h" + +/**If the platform doesn't support placement new, you can disable B3_USE_PLACEMENT_NEW + * then the b3AlignedObjectArray doesn't support objects with virtual methods, and non-trivial constructors/destructors + * You can enable B3_USE_MEMCPY, then swapping elements in the array will use memcpy instead of operator= + * see discussion here: https://bulletphysics.orgphpBB2/viewtopic.php?t=1231 and + * http://www.continuousphysics.com/Bullet/phpBB2/viewtopic.php?t=1240 */ + +public static final int B3_USE_PLACEMENT_NEW = 1; +//#define B3_USE_MEMCPY 1 //disable, because it is cumbersome to find out for each platform where memcpy is defined. It can be in or or otherwise... +// #define B3_ALLOW_ARRAY_COPY_OPERATOR // enabling this can accidently perform deep copies of data if you are not careful + +// #ifdef B3_USE_MEMCPY +// #include +// #include +// #endif //B3_USE_MEMCPY + +// #ifdef B3_USE_PLACEMENT_NEW +// #include +// Targeting ../Bullet3OpenCL/b3ConvexUtilityArray.java + + +// Targeting ../Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java + + +// Targeting ../Bullet3OpenCL/b3OptimizedBvhArray.java + + +// Targeting ../Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java + + +// Targeting ../Bullet3OpenCL/b3BvhInfoArray.java + + +// Targeting ../Bullet3OpenCL/b3BvhSubtreeInfoArray.java + + +// Targeting ../Bullet3OpenCL/b3CompoundOverlappingPairArray.java + + +// Targeting ../Bullet3OpenCL/b3Contact4Array.java + + +// Targeting ../Bullet3OpenCL/b3GpuConstraint4Array.java + + +// Targeting ../Bullet3OpenCL/b3GpuGenericConstraintArray.java + + +// Targeting ../Bullet3OpenCL/b3InertiaDataArray.java + + +// Targeting ../Bullet3OpenCL/b3QuantizedBvhNodeArray.java + + +// Targeting ../Bullet3OpenCL/b3SapAabbArray.java + + +// Targeting ../Bullet3OpenCL/b3SortDataArray.java + + + +// #endif //B3_OBJECT_ARRAY__ + + +// Parsed from Bullet3OpenCL/Initialize/b3OpenCLUtils.h + +/* +Bullet Continuous Collision Detection and Physics Library, http://bulletphysics.org +Copyright (C) 2006 - 2011 Sony Computer Entertainment Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +//original author: Roman Ponomarev +//cleanup by Erwin Coumans + +// #ifndef B3_OPENCL_UTILS_H +// #define B3_OPENCL_UTILS_H + +// #include "b3OpenCLInclude.h" + +// #ifdef __cplusplus +// #endif + + /**C API for OpenCL utilities: convenience functions, see below for C++ API +

+ * CL Context optionally takes a GL context. This is a generic type because we don't really want this code + * to have to understand GL types. It is a HGLRC in _WIN32 or a GLXContext otherwise. */ + public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(int deviceType, IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(int deviceType, IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(int deviceType, int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); + + public static native int b3OpenCLUtils_getNumDevices(@ByVal cl_context cxMainContext); + + public static native @ByVal cl_device_id b3OpenCLUtils_getDevice(@ByVal cl_context cxMainContext, int nr); + + public static native void b3OpenCLUtils_printDeviceInfo(@ByVal cl_device_id device); + + public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, IntPointer pErrNum, @ByVal cl_program prog, @Cast("const char*") BytePointer additionalMacros); + public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, IntBuffer pErrNum, @ByVal cl_program prog, String additionalMacros); + public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, int[] pErrNum, @ByVal cl_program prog, @Cast("const char*") BytePointer additionalMacros); + public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, IntPointer pErrNum, @ByVal cl_program prog, String additionalMacros); + public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, IntBuffer pErrNum, @ByVal cl_program prog, @Cast("const char*") BytePointer additionalMacros); + public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, int[] pErrNum, @ByVal cl_program prog, String additionalMacros); + + //optional + public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, IntPointer pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, IntBuffer pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, int[] pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, IntPointer pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, IntBuffer pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, int[] pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + + //the following optional APIs provide access using specific platform information + public static native int b3OpenCLUtils_getNumPlatforms(IntPointer pErrNum); + public static native int b3OpenCLUtils_getNumPlatforms(IntBuffer pErrNum); + public static native int b3OpenCLUtils_getNumPlatforms(int[] pErrNum); + + /**get the nr'th platform, where nr is in the range [0..getNumPlatforms) */ + public static native @ByVal cl_platform_id b3OpenCLUtils_getPlatform(int nr, IntPointer pErrNum); + public static native @ByVal cl_platform_id b3OpenCLUtils_getPlatform(int nr, IntBuffer pErrNum); + public static native @ByVal cl_platform_id b3OpenCLUtils_getPlatform(int nr, int[] pErrNum); + + public static native void b3OpenCLUtils_printPlatformInfo(@ByVal cl_platform_id platform); + + public static native @Cast("const char*") BytePointer b3OpenCLUtils_getSdkVendorName(); + + /**set the path (directory/folder) where the compiled OpenCL kernel are stored */ + public static native void b3OpenCLUtils_setCachePath(@Cast("const char*") BytePointer path); + public static native void b3OpenCLUtils_setCachePath(String path); + + public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + +// #ifdef __cplusplus + +public static final int B3_MAX_STRING_LENGTH = 1024; +// Targeting ../Bullet3OpenCL/b3OpenCLDeviceInfo.java + + +// Targeting ../Bullet3OpenCL/b3OpenCLPlatformInfo.java + + +// Targeting ../Bullet3OpenCL/b3OpenCLUtils.java + + + +// #endif //__cplusplus + +// #endif // B3_OPENCL_UTILS_H + + +// Parsed from Bullet3OpenCL/ParallelPrimitives/b3BufferInfoCL.h + + +// #ifndef B3_BUFFER_INFO_CL_H +// #define B3_BUFFER_INFO_CL_H + +// #include "b3OpenCLArray.h" +// Targeting ../Bullet3OpenCL/b3BufferInfoCL.java + + + +// #endif //B3_BUFFER_INFO_CL_H + + +// Parsed from Bullet3OpenCL/ParallelPrimitives/b3LauncherCL.h + + +// #ifndef B3_LAUNCHER_CL_H +// #define B3_LAUNCHER_CL_H + +// #include "b3BufferInfoCL.h" +// #include "Bullet3Common/b3MinMax.h" +// #include "b3OpenCLArray.h" +// #include + +// #define B3_DEBUG_SERIALIZE_CL + +// #ifdef _WIN32 +// #endif +public static final int B3_CL_MAX_ARG_SIZE = 16; +// Targeting ../Bullet3OpenCL/b3KernelArgData.java + + +// Targeting ../Bullet3OpenCL/b3LauncherCL.java + + + +// #endif //B3_LAUNCHER_CL_H + + +// Parsed from Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h + +// #ifndef B3_OPENCL_ARRAY_H +// #define B3_OPENCL_ARRAY_H + +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +// Targeting ../Bullet3OpenCL/b3UnsignedCharOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3IntOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3UnsignedIntOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3FloatOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3Int4OCLArray.java + + +// Targeting ../Bullet3OpenCL/b3AabbOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3BvhInfoOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3CollidableOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3Contact4OCLArray.java + + +// Targeting ../Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3GpuChildShapeOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3GpuConstraint4OCLArray.java + + +// Targeting ../Bullet3OpenCL/b3GpuFaceOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3InertiaDataOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3Int2OCLArray.java + + +// Targeting ../Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3RayInfoOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3RigidBodyDataOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3SapAabbOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3SortDataOCLArray.java + + +// Targeting ../Bullet3OpenCL/b3Vector3OCLArray.java + + + +// #endif //B3_OPENCL_ARRAY_H + + +// Parsed from Bullet3OpenCL/ParallelPrimitives/b3FillCL.h + +// #ifndef B3_FILL_CL_H +// #define B3_FILL_CL_H + +// #include "b3OpenCLArray.h" +// #include "Bullet3Common/b3Scalar.h" + +// #include "Bullet3Common/shared/b3Int2.h" +// #include "Bullet3Common/shared/b3Int4.h" +// Targeting ../Bullet3OpenCL/b3FillCL.java + + + +// #endif //B3_FILL_CL_H + + +// Parsed from Bullet3OpenCL/ParallelPrimitives/b3PrefixScanFloat4CL.h + + +// #ifndef B3_PREFIX_SCAN_CL_H +// #define B3_PREFIX_SCAN_CL_H + +// #include "b3OpenCLArray.h" +// #include "b3BufferInfoCL.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Common/b3Vector3.h" +// Targeting ../Bullet3OpenCL/b3PrefixScanFloat4CL.java + + + +// #endif //B3_PREFIX_SCAN_CL_H + + +// Parsed from Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h + + +// #ifndef B3_RADIXSORT32_H +// #define B3_RADIXSORT32_H + +// #include "b3OpenCLArray.h" +// Targeting ../Bullet3OpenCL/b3SortData.java + + +// #include "b3BufferInfoCL.h" +// Targeting ../Bullet3OpenCL/b3RadixSort32CL.java + + +// #endif //B3_RADIXSORT32_H + + +// Parsed from Bullet3OpenCL/ParallelPrimitives/b3BoundSearchCL.h + +/* +Copyright (c) 2012 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Takahiro Harada + +// #ifndef B3_BOUNDSEARCH_H +// #define B3_BOUNDSEARCH_H + +// #pragma once + +/*#include +#include +#include +#include +*/ + +// #include "b3OpenCLArray.h" +// #include "b3FillCL.h" +// #include "b3RadixSort32CL.h" +// Targeting ../Bullet3OpenCL/b3BoundSearchCL.java + + + +// #endif //B3_BOUNDSEARCH_H + + +// Parsed from Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h + +// #ifndef B3_SAP_AABB_H +// #define B3_SAP_AABB_H + +// #include "Bullet3Common/b3Scalar.h" +// #include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h" +// Targeting ../Bullet3OpenCL/b3SapAabb.java + + + +// #endif //B3_SAP_AABB_H + + +// Parsed from Bullet3OpenCL/BroadphaseCollision/b3GpuBroadphaseInterface.h + + +// #ifndef B3_GPU_BROADPHASE_INTERFACE_H +// #define B3_GPU_BROADPHASE_INTERFACE_H + +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +// #include "Bullet3Common/b3Vector3.h" +// #include "b3SapAabb.h" +// #include "Bullet3Common/shared/b3Int2.h" +// #include "Bullet3Common/shared/b3Int4.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" +// Targeting ../Bullet3OpenCL/b3GpuBroadphaseInterface.java + + + +// #endif //B3_GPU_BROADPHASE_INTERFACE_H + + +// Parsed from Bullet3OpenCL/BroadphaseCollision/b3GpuGridBroadphase.h + +// #ifndef B3_GPU_GRID_BROADPHASE_H +// #define B3_GPU_GRID_BROADPHASE_H + +// #include "b3GpuBroadphaseInterface.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h" +// Targeting ../Bullet3OpenCL/b3ParamsGridBroadphaseCL.java + + +// Targeting ../Bullet3OpenCL/b3GpuGridBroadphase.java + + + +// #endif //B3_GPU_GRID_BROADPHASE_H + +// Parsed from Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvhBroadphase.h + +/* +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Initial Author Jackson Lee, 2014 + +// #ifndef B3_GPU_PARALLEL_LINEAR_BVH_BROADPHASE_H +// #define B3_GPU_PARALLEL_LINEAR_BVH_BROADPHASE_H + +// #include "Bullet3OpenCL/BroadphaseCollision/b3GpuBroadphaseInterface.h" + +// #include "b3GpuParallelLinearBvh.h" +// Targeting ../Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java + + + +// #endif + + +// Parsed from Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvh.h + +/* +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Initial Author Jackson Lee, 2014 + +// #ifndef B3_GPU_PARALLEL_LINEAR_BVH_H +// #define B3_GPU_PARALLEL_LINEAR_BVH_H + +//#include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h" +// #include "Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h" +// #include "Bullet3Common/shared/b3Int2.h" +// #include "Bullet3Common/shared/b3Int4.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h" + +// #include "Bullet3OpenCL/ParallelPrimitives/b3FillCL.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3PrefixScanCL.h" + +// #include "Bullet3OpenCL/BroadphaseCollision/kernels/parallelLinearBvhKernels.h" + +// #define b3Int64 cl_long +// Targeting ../Bullet3OpenCL/b3GpuParallelLinearBvh.java + + + +// #endif + + +// Parsed from Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.h + +// #ifndef B3_GPU_SAP_BROADPHASE_H +// #define B3_GPU_SAP_BROADPHASE_H + +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3FillCL.h" //b3Int2 +// #include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h" + +// #include "b3SapAabb.h" +// #include "Bullet3Common/shared/b3Int2.h" + +// #include "b3GpuBroadphaseInterface.h" +// Targeting ../Bullet3OpenCL/b3GpuSapBroadphase.java + + + +// #endif //B3_GPU_SAP_BROADPHASE_H + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3BvhInfo.h + +// #ifndef B3_BVH_INFO_H +// #define B3_BVH_INFO_H + +// #include "Bullet3Common/b3Vector3.h" +// Targeting ../Bullet3OpenCL/b3BvhInfo.java + + + +// #endif //B3_BVH_INFO_H + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.h + + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_CONTACT_CACHE_H +// #define B3_CONTACT_CACHE_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Common/b3Transform.h" +// #include "Bullet3Common/b3AlignedAllocator.h" + +/**maximum contact breaking and merging threshold */ +public static native @Cast("b3Scalar") float gContactBreakingThreshold(); public static native void gContactBreakingThreshold(float setter); + +public static final int MANIFOLD_CACHE_SIZE = 4; +// Targeting ../Bullet3OpenCL/b3ContactCache.java + + + +// #endif //B3_CONTACT_CACHE_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.h + + +// #ifndef _CONVEX_HULL_CONTACT_H +// #define _CONVEX_HULL_CONTACT_H + +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h" +// #include "Bullet3Common/shared/b3Int2.h" +// #include "Bullet3Common/shared/b3Int4.h" +// #include "b3OptimizedBvh.h" +// #include "b3BvhInfo.h" +// #include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h" +// Targeting ../Bullet3OpenCL/GpuSatCollision.java + + + +// #endif //_CONVEX_HULL_CONTACT_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3ConvexPolyhedronCL.h + +// #ifndef CONVEX_POLYHEDRON_CL +// #define CONVEX_POLYHEDRON_CL + +// #include "Bullet3Common/b3Transform.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h" + +// #endif //CONVEX_POLYHEDRON_CL + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3GjkEpa.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2008 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the +use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not +claim that you wrote the original software. If you use this software in a +product, an acknowledgment in the product documentation would be appreciated +but is not required. +2. Altered source versions must be plainly marked as such, and must not be +misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/* +GJK-EPA collision solver by Nathanael Presson, 2008 +*/ +// #ifndef B3_GJK_EPA2_H +// #define B3_GJK_EPA2_H + +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Common/b3Transform.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h" +// Targeting ../Bullet3OpenCL/b3GjkEpaSolver2.java + + + +// #endif //B3_GJK_EPA2_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3OptimizedBvh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +/**Contains contributions from Disney Studio's */ + +// #ifndef B3_OPTIMIZED_BVH_H +// #define B3_OPTIMIZED_BVH_H + +// #include "b3QuantizedBvh.h" +// Targeting ../Bullet3OpenCL/b3OptimizedBvh.java + + + +// #endif //B3_OPTIMIZED_BVH_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_QUANTIZED_BVH_H +// #define B3_QUANTIZED_BVH_H +// Targeting ../Bullet3OpenCL/b3Serializer.java + + + +//#define DEBUG_CHECK_DEQUANTIZATION 1 +// #ifdef DEBUG_CHECK_DEQUANTIZATION +// #endif //DEBUG_CHECK_DEQUANTIZATION + +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Common/b3AlignedAllocator.h" + +// #ifdef B3_USE_DOUBLE_PRECISION +// #else +// #define b3QuantizedBvhData b3QuantizedBvhFloatData +// #define b3OptimizedBvhNodeData b3OptimizedBvhNodeFloatData +public static final String b3QuantizedBvhDataName = "b3QuantizedBvhFloatData"; +// #endif + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3BvhSubtreeInfoData.h" + +//http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclang/html/vclrf__m128.asp + +//Note: currently we have 16 bytes per quantized node +public static final int MAX_SUBTREE_SIZE_IN_BYTES = 2048; + +// 10 gives the potential for 1024 parts, with at most 2^21 (2097152) (minus one +// actually) triangles each (since the sign bit is reserved +public static final int MAX_NUM_PARTS_IN_BITS = 10; +// Targeting ../Bullet3OpenCL/b3QuantizedBvhNode.java + + +// Targeting ../Bullet3OpenCL/b3OptimizedBvhNode.java + + +// Targeting ../Bullet3OpenCL/b3BvhSubtreeInfo.java + + +// Targeting ../Bullet3OpenCL/b3NodeOverlapCallback.java + + + +// #include "Bullet3Common/b3AlignedAllocator.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" + +/**for code readability: */ +// Targeting ../Bullet3OpenCL/b3QuantizedBvh.java + + +// Targeting ../Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java + + +// Targeting ../Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java + + +// Targeting ../Bullet3OpenCL/b3QuantizedBvhFloatData.java + + +// Targeting ../Bullet3OpenCL/b3QuantizedBvhDoubleData.java + + + + + +// #endif //B3_QUANTIZED_BVH_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3StridingMeshInterface.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_STRIDING_MESHINTERFACE_H +// #define B3_STRIDING_MESHINTERFACE_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "b3TriangleCallback.h" +//#include "b3ConcaveShape.h" + +/** enum PHY_ScalarType */ +public static final int + PHY_FLOAT = 0, + PHY_DOUBLE = 1, + PHY_INTEGER = 2, + PHY_SHORT = 3, + PHY_FIXEDPOINT88 = 4, + PHY_UCHAR = 5; +// Targeting ../Bullet3OpenCL/b3StridingMeshInterface.java + + +// Targeting ../Bullet3OpenCL/b3IntIndexData.java + + +// Targeting ../Bullet3OpenCL/b3ShortIntIndexData.java + + +// Targeting ../Bullet3OpenCL/b3ShortIntIndexTripletData.java + + +// Targeting ../Bullet3OpenCL/b3CharIndexTripletData.java + + +// Targeting ../Bullet3OpenCL/b3MeshPartData.java + + +// Targeting ../Bullet3OpenCL/b3StridingMeshInterfaceData.java + + + + + +// #endif //B3_STRIDING_MESHINTERFACE_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3VectorFloat4.h + +// #ifndef B3_VECTOR_FLOAT4_H +// #define B3_VECTOR_FLOAT4_H + +// #include "Bullet3Common/b3Transform.h" + +//#define cross3(a,b) (a.cross(b)) +// #define float4 b3Vector3 +//#define make_float4(x,y,z,w) b3Vector4(x,y,z,w) + +// #endif //B3_VECTOR_FLOAT4_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3SupportMappings.h + + +// #ifndef B3_SUPPORT_MAPPINGS_H +// #define B3_SUPPORT_MAPPINGS_H + +// #include "Bullet3Common/b3Transform.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "b3VectorFloat4.h" +// Targeting ../Bullet3OpenCL/b3GjkPairDetector.java + + + +public static native @ByVal b3Vector3 localGetSupportVertexWithMargin(@Const @ByRef b3Vector3 supportVec, @Const b3ConvexPolyhedronData hull, + @Const @ByRef b3Vector3Array verticesA, @Cast("b3Scalar") float margin); + +public static native @ByVal b3Vector3 localGetSupportVertexWithoutMargin(@Const @ByRef b3Vector3 supportVec, @Const b3ConvexPolyhedronData hull, + @Const @ByRef b3Vector3Array verticesA); + +// #endif //B3_SUPPORT_MAPPINGS_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3TriangleCallback.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_TRIANGLE_CALLBACK_H +// #define B3_TRIANGLE_CALLBACK_H + +// #include "Bullet3Common/b3Vector3.h" +// Targeting ../Bullet3OpenCL/b3TriangleCallback.java + + +// Targeting ../Bullet3OpenCL/b3InternalTriangleIndexCallback.java + + + +// #endif //B3_TRIANGLE_CALLBACK_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3TriangleIndexVertexArray.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2009 Erwin Coumans http://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_TRIANGLE_INDEX_VERTEX_ARRAY_H +// #define B3_TRIANGLE_INDEX_VERTEX_ARRAY_H + +// #include "b3StridingMeshInterface.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Common/b3Scalar.h" +// Targeting ../Bullet3OpenCL/b3IndexedMesh.java + + +// Targeting ../Bullet3OpenCL/b3TriangleIndexVertexArray.java + + + +// #endif //B3_TRIANGLE_INDEX_VERTEX_ARRAY_H + + +// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3VoronoiSimplexSolver.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2003-2006 Erwin Coumans https://bulletphysics.org + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_VORONOI_SIMPLEX_SOLVER_H +// #define B3_VORONOI_SIMPLEX_SOLVER_H + +// #include "Bullet3Common/b3Vector3.h" + +public static final int VORONOI_SIMPLEX_MAX_VERTS = 5; + +/**disable next define, or use defaultCollisionConfiguration->getSimplexSolver()->setEqualVertexThreshold(0.f) to disable/configure */ +//#define BT_USE_EQUAL_VERTEX_THRESHOLD +public static final double VORONOI_DEFAULT_EQUAL_VERTEX_THRESHOLD = 0.0001f; +// Targeting ../Bullet3OpenCL/b3UsageBitfield.java + + +// Targeting ../Bullet3OpenCL/b3SubSimplexClosestResult.java + + +// Targeting ../Bullet3OpenCL/b3VoronoiSimplexSolver.java + + + +// #endif //B3_VORONOI_SIMPLEX_SOLVER_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuConstraint4.h + + +// #ifndef B3_CONSTRAINT4_h +// #define B3_CONSTRAINT4_h +// #include "Bullet3Common/b3Vector3.h" + +// #include "Bullet3Dynamics/shared/b3ContactConstraint4.h" +// Targeting ../Bullet3OpenCL/b3GpuConstraint4.java + + + +// #endif //B3_CONSTRAINT4_h + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuGenericConstraint.h + +/* +Copyright (c) 2013 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Erwin Coumans + +// #ifndef B3_GPU_GENERIC_CONSTRAINT_H +// #define B3_GPU_GENERIC_CONSTRAINT_H + +// #include "Bullet3Common/b3Quaternion.h" +/** enum B3_CONSTRAINT_FLAGS */ +public static final int + B3_CONSTRAINT_FLAG_ENABLED = 1; + +/** enum b3GpuGenericConstraintType */ +public static final int + B3_GPU_POINT2POINT_CONSTRAINT_TYPE = 3, + B3_GPU_FIXED_CONSTRAINT_TYPE = 4, + // B3_HINGE_CONSTRAINT_TYPE, + // B3_CONETWIST_CONSTRAINT_TYPE, + // B3_D6_CONSTRAINT_TYPE, + // B3_SLIDER_CONSTRAINT_TYPE, + // B3_CONTACT_CONSTRAINT_TYPE, + // B3_D6_SPRING_CONSTRAINT_TYPE, + // B3_GEAR_CONSTRAINT_TYPE, + + B3_GPU_MAX_CONSTRAINT_TYPE = 5; +// Targeting ../Bullet3OpenCL/b3GpuConstraintInfo2.java + + +// Targeting ../Bullet3OpenCL/b3GpuGenericConstraint.java + + + +// #endif //B3_GPU_GENERIC_CONSTRAINT_H + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuJacobiContactSolver.h + + +// #ifndef B3_GPU_JACOBI_CONTACT_SOLVER_H +// #define B3_GPU_JACOBI_CONTACT_SOLVER_H +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +//#include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" +// Targeting ../Bullet3OpenCL/b3JacobiSolverInfo.java + + +// Targeting ../Bullet3OpenCL/b3GpuJacobiContactSolver.java + + +// #endif //B3_GPU_JACOBI_CONTACT_SOLVER_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuNarrowPhase.h + +// #ifndef B3_GPU_NARROWPHASE_H +// #define B3_GPU_NARROWPHASE_H + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Common/b3Vector3.h" +// Targeting ../Bullet3OpenCL/b3GpuNarrowPhase.java + + + +// #endif //B3_GPU_NARROWPHASE_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuNarrowPhaseInternalData.h + + +// #ifndef B3_GPU_NARROWPHASE_INTERNAL_DATA_H +// #define B3_GPU_NARROWPHASE_INTERNAL_DATA_H + +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3ConvexPolyhedronData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3Config.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" + +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Common/b3Vector3.h" + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h" +// #include "Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h" + +// #include "Bullet3OpenCL/NarrowphaseCollision/b3QuantizedBvh.h" +// #include "Bullet3OpenCL/NarrowphaseCollision/b3BvhInfo.h" +// #include "Bullet3Common/shared/b3Int4.h" +// #include "Bullet3Common/shared/b3Int2.h" +// Targeting ../Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java + + + +// #endif //B3_GPU_NARROWPHASE_INTERNAL_DATA_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuPgsConstraintSolver.h + +/* +Copyright (c) 2013 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Erwin Coumans + +// #ifndef B3_GPU_PGS_CONSTRAINT_SOLVER_H +// #define B3_GPU_PGS_CONSTRAINT_SOLVER_H +// Targeting ../Bullet3OpenCL/b3ContactPoint.java + + +// Targeting ../Bullet3OpenCL/b3Dispatcher.java + + + +// #include "Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h" +// #include "Bullet3Dynamics/ConstraintSolver/b3ContactSolverInfo.h" +// #include "b3GpuSolverBody.h" +// #include "b3GpuSolverConstraint.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" + +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +// #include "b3GpuGenericConstraint.h" +// Targeting ../Bullet3OpenCL/b3GpuPgsConstraintSolver.java + + + +// #endif //B3_GPU_PGS_CONSTRAINT_SOLVER_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuPgsContactSolver.h + + +// #ifndef B3_GPU_BATCHING_PGS_SOLVER_H +// #define B3_GPU_BATCHING_PGS_SOLVER_H + +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h" +// #include "b3GpuConstraint4.h" +// Targeting ../Bullet3OpenCL/b3GpuPgsContactSolver.java + + + +// #endif //B3_GPU_BATCHING_PGS_SOLVER_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipeline.h + +/* +Copyright (c) 2013 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Erwin Coumans + +// #ifndef B3_GPU_RIGIDBODY_PIPELINE_H +// #define B3_GPU_RIGIDBODY_PIPELINE_H + +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3Config.h" + +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h" +// Targeting ../Bullet3OpenCL/b3GpuRigidBodyPipeline.java + + + +// #endif //B3_GPU_RIGIDBODY_PIPELINE_H + +// Parsed from Bullet3OpenCL/Raycast/b3GpuRaycast.h + +// #ifndef B3_GPU_RAYCAST_H +// #define B3_GPU_RAYCAST_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" + +// #include "Bullet3Common/b3AlignedObjectArray.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3RaycastInfo.h" +// Targeting ../Bullet3OpenCL/b3GpuRaycast.java + + + +// #endif //B3_GPU_RAYCAST_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuRigidBodyPipelineInternalData.h + +/* +Copyright (c) 2013 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Erwin Coumans + +// #ifndef B3_GPU_RIGIDBODY_PIPELINE_INTERNAL_DATA_H +// #define B3_GPU_RIGIDBODY_PIPELINE_INTERNAL_DATA_H + +// #include "Bullet3OpenCL/Initialize/b3OpenCLInclude.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" + +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" + +// #include "Bullet3OpenCL/BroadphaseCollision/b3SapAabb.h" +// #include "Bullet3Dynamics/ConstraintSolver/b3TypedConstraint.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3Config.h" + +// #include "Bullet3Collision/BroadPhaseCollision/b3OverlappingPair.h" +// #include "Bullet3OpenCL/RigidBody/b3GpuGenericConstraint.h" +// Targeting ../Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java + + + +// #endif //B3_GPU_RIGIDBODY_PIPELINE_INTERNAL_DATA_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuSolverBody.h + +/* +Copyright (c) 2013 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Erwin Coumans + +// #ifndef B3_GPU_SOLVER_BODY_H +// #define B3_GPU_SOLVER_BODY_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Common/b3Matrix3x3.h" + +// #include "Bullet3Common/b3AlignedAllocator.h" +// #include "Bullet3Common/b3TransformUtil.h" +// Targeting ../Bullet3OpenCL/b3GpuSolverBody.java + + + +// #endif //B3_SOLVER_BODY_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3GpuSolverConstraint.h + +/* +Bullet Continuous Collision Detection and Physics Library +Copyright (c) 2013 Erwin Coumans http://github.com/erwincoumans/bullet3 + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ + +// #ifndef B3_GPU_SOLVER_CONSTRAINT_H +// #define B3_GPU_SOLVER_CONSTRAINT_H + +// #include "Bullet3Common/b3Vector3.h" +// #include "Bullet3Common/b3Matrix3x3.h" +//#include "b3JacobianEntry.h" +// #include "Bullet3Common/b3AlignedObjectArray.h" +// Targeting ../Bullet3OpenCL/b3GpuSolverConstraint.java + + + +// #endif //B3_GPU_SOLVER_CONSTRAINT_H + + +// Parsed from Bullet3OpenCL/RigidBody/b3Solver.h + +/* +Copyright (c) 2012 Advanced Micro Devices, Inc. + +This software is provided 'as-is', without any express or implied warranty. +In no event will the authors be held liable for any damages arising from the use of this software. +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it freely, +subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +3. This notice may not be removed or altered from any source distribution. +*/ +//Originally written by Takahiro Harada + +// #ifndef __ADL_SOLVER_H +// #define __ADL_SOLVER_H + +// #include "Bullet3OpenCL/ParallelPrimitives/b3OpenCLArray.h" +// #include "b3GpuConstraint4.h" + +// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" +// #include "Bullet3Collision/NarrowPhaseCollision/b3Contact4.h" + +// #include "Bullet3OpenCL/ParallelPrimitives/b3PrefixScanCL.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3RadixSort32CL.h" +// #include "Bullet3OpenCL/ParallelPrimitives/b3BoundSearchCL.h" + +// #include "Bullet3OpenCL/Initialize/b3OpenCLUtils.h" + +// #define B3NEXTMULTIPLEOF(num, alignment) (((num) / (alignment) + (((num) % (alignment) == 0) ? 0 : 1)) * (alignment)) + +/** enum */ +public static final int + B3_SOLVER_N_SPLIT_X = 8, //16,//4, + B3_SOLVER_N_SPLIT_Y = 4, //16,//4, + B3_SOLVER_N_SPLIT_Z = 8, //, + B3_SOLVER_N_CELLS = B3_SOLVER_N_SPLIT_X * B3_SOLVER_N_SPLIT_Y * B3_SOLVER_N_SPLIT_Z, + B3_SOLVER_N_BATCHES = 8, //4,//8,//4, + B3_MAX_NUM_BATCHES = 128; +// Targeting ../Bullet3OpenCL/b3SolverBase.java + + +// Targeting ../Bullet3OpenCL/b3Solver.java + + + +// #endif //__ADL_SOLVER_H + + +} From ecbf1b5929738871701fff2b9733772521c2d719 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 8 Mar 2022 18:16:50 +0800 Subject: [PATCH 69/81] Skip undefined symbols --- .../bullet/presets/Bullet3Collision.java | 19 +++++++++++++++++++ .../bullet/presets/Bullet3Dynamics.java | 16 ++++++++++++++++ .../bullet/presets/Bullet3OpenCL.java | 4 +++- 3 files changed, 38 insertions(+), 1 deletion(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java index 620d5f7279c..7ca9f78f618 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java @@ -114,7 +114,26 @@ public void map(InfoMap infoMap) { "b3AlignedObjectArray::findLinearSearch", "b3AlignedObjectArray::findLinearSearch2", "b3AlignedObjectArray::remove", + "b3ConvexUtility::testContainment", + "b3CpuNarrowPhase::getBodiesCpu", + "b3CpuNarrowPhase::getCollidablesCpu", "b3CpuNarrowPhase::getInternalData", + "b3CpuNarrowPhase::getNumBodiesGpu", + "b3CpuNarrowPhase::getNumBodyInertiasGpu", + "b3CpuNarrowPhase::getNumCollidablesGpu", + "b3CpuNarrowPhase::getNumRigidBodies", + "b3CpuNarrowPhase::getObjectTransformFromCpu", + "b3CpuNarrowPhase::readbackAllBodiesToCpu", + "b3CpuNarrowPhase::registerCompoundShape", + "b3CpuNarrowPhase::registerConcaveMesh", + "b3CpuNarrowPhase::registerFace", + "b3CpuNarrowPhase::registerPlaneShape", + "b3CpuNarrowPhase::registerSphereShape", + "b3CpuNarrowPhase::reset", + "b3CpuNarrowPhase::setObjectTransform", + "b3CpuNarrowPhase::setObjectTransformCpu", + "b3CpuNarrowPhase::setObjectVelocityCpu", + "b3CpuNarrowPhase::writeAllBodiesToGpu", "b3DynamicBvh::extractLeaves", "b3DynamicBvh::m_rayTestStack" ).skip()) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java index c7d62379ec4..04b869c43c4 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java @@ -73,6 +73,22 @@ public void map(InfoMap infoMap) { .put(new Info("b3AlignedObjectArray").pointerTypes("b3TypedConstraintArray")) .put(new Info("b3ContactConstraint4_t").pointerTypes("b3ContactConstraint4")) + + .put(new Info( + "b3CpuRigidBodyPipeline::addConstraint", + "b3CpuRigidBodyPipeline::castRays", + "b3CpuRigidBodyPipeline::copyConstraintsToHost", + "b3CpuRigidBodyPipeline::createFixedConstraint", + "b3CpuRigidBodyPipeline::createPoint2PointConstraint", + "b3CpuRigidBodyPipeline::registerConvexPolyhedron", + "b3CpuRigidBodyPipeline::removeConstraint", + "b3CpuRigidBodyPipeline::removeConstraintByUid", + "b3CpuRigidBodyPipeline::reset", + "b3CpuRigidBodyPipeline::setGravity", + "b3CpuRigidBodyPipeline::writeAllInstancesToGpu", + "b3RotationalLimitMotor::solveAngularLimits", + "b3TranslationalLimitMotor::solveLinearAxis" + ).skip()) ; } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java index 7694e884c02..e67ca51fdb1 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java @@ -59,7 +59,6 @@ "Bullet3OpenCL/BroadphaseCollision/b3GpuParallelLinearBvh.h", "Bullet3OpenCL/BroadphaseCollision/b3GpuSapBroadphase.h", "Bullet3OpenCL/NarrowphaseCollision/b3BvhInfo.h", - "Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.h", "Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.h", "Bullet3OpenCL/NarrowphaseCollision/b3ConvexPolyhedronCL.h", "Bullet3OpenCL/NarrowphaseCollision/b3GjkEpa.h", @@ -154,7 +153,9 @@ public void map(InfoMap infoMap) { "GpuSatCollision::m_sepNormals", "GpuSatCollision::m_totalContactsOut", "GpuSatCollision::m_unitSphereDirections", + "b3GpuNarrowPhase::setObjectTransform", "b3GpuPgsConstraintSolver::sortConstraintByBatch3", + "b3GpuRigidBodyPipeline::registerConvexPolyhedron", "b3GpuSapBroadphase::m_allAabbsGPU", "b3GpuSapBroadphase::m_dst", "b3GpuSapBroadphase::m_gpuSmallSortData", @@ -165,6 +166,7 @@ public void map(InfoMap infoMap) { "b3GpuSapBroadphase::m_smallAabbsMappingGPU", "b3GpuSapBroadphase::m_sum", "b3GpuSapBroadphase::m_sum2", + "b3LauncherCL::validateResults", "b3Solver::m_batchSizes", "b3Solver::m_scan" ).skip()) From dcdad47d3ff337d8ef71e5debe5f18f0070b22b3 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Tue, 8 Mar 2022 18:19:43 +0800 Subject: [PATCH 70/81] Update generated code for bullet's preset See parent commit. --- .../Bullet3Collision/b3ConvexUtility.java | 2 +- .../Bullet3Collision/b3CpuNarrowPhase.java | 50 ++++++--------- .../b3CpuRigidBodyPipeline.java | 34 +++++------ .../b3RotationalLimitMotor.java | 2 +- .../b3TranslationalLimitMotor.java | 9 +-- .../bullet/Bullet3OpenCL/b3ContactCache.java | 61 ------------------- .../Bullet3OpenCL/b3GpuNarrowPhase.java | 4 +- .../Bullet3OpenCL/b3GpuRigidBodyPipeline.java | 2 +- .../bullet/Bullet3OpenCL/b3LauncherCL.java | 4 +- .../bytedeco/bullet/global/Bullet3OpenCL.java | 36 ----------- 10 files changed, 40 insertions(+), 164 deletions(-) delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactCache.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexUtility.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexUtility.java index df1b3838c1d..78f9b4c6d7f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexUtility.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3ConvexUtility.java @@ -46,5 +46,5 @@ public class b3ConvexUtility extends Pointer { public native @Cast("bool") boolean initializePolyhedralFeatures(@Const b3Vector3 orgVertices, int numVertices); public native void initialize(); - public native @Cast("bool") boolean testContainment(); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CpuNarrowPhase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CpuNarrowPhase.java index ea38c4d61ad..b29ecf821cb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CpuNarrowPhase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Collision/b3CpuNarrowPhase.java @@ -22,15 +22,13 @@ public class b3CpuNarrowPhase extends Pointer { public b3CpuNarrowPhase(@Const @ByRef b3Config config) { super((Pointer)null); allocate(config); } private native void allocate(@Const @ByRef b3Config config); - public native int registerSphereShape(float radius); - public native int registerPlaneShape(@Const @ByRef b3Vector3 planeNormal, float planeConstant); + + - public native int registerCompoundShape(b3GpuChildShapeArray childShapes); - public native int registerFace(@Const @ByRef b3Vector3 faceNormal, float faceConstant); + + - public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const FloatPointer scaling); - public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const FloatBuffer scaling); - public native int registerConcaveMesh(b3Vector3Array vertices, b3IntArray indices, @Const float[] scaling); + //do they need to be merged? @@ -40,36 +38,28 @@ public class b3CpuNarrowPhase extends Pointer { public native int registerConvexHullShape(@Const float[] vertices, int strideInBytes, int numVertices, @Const float[] scaling); //int registerRigidBody(int collidableIndex, float mass, const float* position, const float* orientation, const float* aabbMin, const float* aabbMax,bool writeToGpu); - public native void setObjectTransform(@Const FloatPointer _position, @Const FloatPointer orientation, int bodyIndex); - public native void setObjectTransform(@Const FloatBuffer _position, @Const FloatBuffer orientation, int bodyIndex); - public native void setObjectTransform(@Const float[] _position, @Const float[] orientation, int bodyIndex); - - public native void writeAllBodiesToGpu(); - public native void reset(); - public native void readbackAllBodiesToCpu(); - public native @Cast("bool") boolean getObjectTransformFromCpu(FloatPointer _position, FloatPointer orientation, int bodyIndex); - public native @Cast("bool") boolean getObjectTransformFromCpu(FloatBuffer _position, FloatBuffer orientation, int bodyIndex); - public native @Cast("bool") boolean getObjectTransformFromCpu(float[] _position, float[] orientation, int bodyIndex); - - public native void setObjectTransformCpu(FloatPointer _position, FloatPointer orientation, int bodyIndex); - public native void setObjectTransformCpu(FloatBuffer _position, FloatBuffer orientation, int bodyIndex); - public native void setObjectTransformCpu(float[] _position, float[] orientation, int bodyIndex); - public native void setObjectVelocityCpu(FloatPointer linVel, FloatPointer angVel, int bodyIndex); - public native void setObjectVelocityCpu(FloatBuffer linVel, FloatBuffer angVel, int bodyIndex); - public native void setObjectVelocityCpu(float[] linVel, float[] angVel, int bodyIndex); + + + + + + + + + //virtual void computeContacts(cl_mem broadphasePairs, int numBroadphasePairs, cl_mem aabbsWorldSpace, int numObjects); public native void computeContacts(@ByRef b3Int4Array pairs, @ByRef b3AabbArray aabbsWorldSpace, @ByRef b3RigidBodyDataArray bodies); - public native @Const b3RigidBodyData getBodiesCpu(); + //struct b3RigidBodyData* getBodiesCpu(); - public native int getNumBodiesGpu(); + - public native int getNumBodyInertiasGpu(); + - public native @Const b3Collidable getCollidablesCpu(); - public native int getNumCollidablesGpu(); + + /*const struct b3Contact4* getContactsCPU() const; @@ -79,7 +69,7 @@ public class b3CpuNarrowPhase extends Pointer { public native @Const @ByRef b3Contact4DataArray getContacts(); - public native int getNumRigidBodies(); + public native int allocateCollidable(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.java index 1730b03a8cb..e9ae973ff7c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3CpuRigidBodyPipeline.java @@ -31,30 +31,24 @@ public class b3CpuRigidBodyPipeline extends Pointer { public native void computeContactPoints(); public native void solveContactConstraints(); - public native int registerConvexPolyhedron(b3ConvexUtility convex); + public native int registerPhysicsInstance(float mass, @Const FloatPointer _position, @Const FloatPointer orientation, int collisionShapeIndex, int userData); public native int registerPhysicsInstance(float mass, @Const FloatBuffer _position, @Const FloatBuffer orientation, int collisionShapeIndex, int userData); public native int registerPhysicsInstance(float mass, @Const float[] _position, @Const float[] orientation, int collisionShapeIndex, int userData); - public native void writeAllInstancesToGpu(); - public native void copyConstraintsToHost(); - public native void setGravity(@Const FloatPointer grav); - public native void setGravity(@Const FloatBuffer grav); - public native void setGravity(@Const float[] grav); - public native void reset(); - - public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const FloatPointer pivotInA, @Const FloatPointer pivotInB, float breakingThreshold); - public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const FloatBuffer pivotInA, @Const FloatBuffer pivotInB, float breakingThreshold); - public native int createPoint2PointConstraint(int bodyA, int bodyB, @Const float[] pivotInA, @Const float[] pivotInB, float breakingThreshold); - public native int createFixedConstraint(int bodyA, int bodyB, @Const FloatPointer pivotInA, @Const FloatPointer pivotInB, @Const FloatPointer relTargetAB, float breakingThreshold); - public native int createFixedConstraint(int bodyA, int bodyB, @Const FloatBuffer pivotInA, @Const FloatBuffer pivotInB, @Const FloatBuffer relTargetAB, float breakingThreshold); - public native int createFixedConstraint(int bodyA, int bodyB, @Const float[] pivotInA, @Const float[] pivotInB, @Const float[] relTargetAB, float breakingThreshold); - public native void removeConstraintByUid(int uid); - - public native void addConstraint(b3TypedConstraint constraint); - public native void removeConstraint(b3TypedConstraint constraint); - - public native void castRays(@Const @ByRef b3RayInfoArray rays, @ByRef b3RayHitArray hitResults); + + + + + + + + + + + + + public native @Const b3RigidBodyData getBodyBuffer(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RotationalLimitMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RotationalLimitMotor.java index 1aeea4490ee..05d52b56228 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RotationalLimitMotor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3RotationalLimitMotor.java @@ -86,5 +86,5 @@ public class b3RotationalLimitMotor extends Pointer { public native int testLimitValue(@Cast("b3Scalar") float test_value); /** apply the correction impulses for two bodies */ - public native @Cast("b3Scalar") float solveAngularLimits(@Cast("b3Scalar") float timeStep, @ByRef b3Vector3 axis, @Cast("b3Scalar") float jacDiagABInv, b3RigidBodyData body0, b3RigidBodyData body1); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TranslationalLimitMotor.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TranslationalLimitMotor.java index 4448b652c71..fc148be0cc2 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TranslationalLimitMotor.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3Dynamics/b3TranslationalLimitMotor.java @@ -78,12 +78,5 @@ public class b3TranslationalLimitMotor extends Pointer { public native @Cast("bool") boolean needApplyForce(int limitIndex); public native int testLimitValue(int limitIndex, @Cast("b3Scalar") float test_value); - public native @Cast("b3Scalar") float solveLinearAxis( - @Cast("b3Scalar") float timeStep, - @Cast("b3Scalar") float jacDiagABInv, - @ByRef b3RigidBodyData body1, @Const @ByRef b3Vector3 pointInA, - @ByRef b3RigidBodyData body2, @Const @ByRef b3Vector3 pointInB, - int limit_index, - @Const @ByRef b3Vector3 axis_normal_on_a, - @Const @ByRef b3Vector3 anchorPos); + } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactCache.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactCache.java deleted file mode 100644 index ffa7d1a0baf..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactCache.java +++ /dev/null @@ -1,61 +0,0 @@ -// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet.Bullet3OpenCL; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; -import org.bytedeco.bullet.Bullet3Common.*; -import static org.bytedeco.bullet.global.Bullet3Common.*; -import org.bytedeco.bullet.Bullet3Collision.*; -import static org.bytedeco.bullet.global.Bullet3Collision.*; -import org.bytedeco.bullet.Bullet3Dynamics.*; -import static org.bytedeco.bullet.global.Bullet3Dynamics.*; - -import static org.bytedeco.bullet.global.Bullet3OpenCL.*; - - -/**b3ContactCache is a contact point cache, it stays persistent as long as objects are overlapping in the broadphase. - * Those contact points are created by the collision narrow phase. - * The cache can be empty, or hold 1,2,3 or 4 points. Some collision algorithms (GJK) might only add one point at a time. - * updates/refreshes old contact points, and throw them away if necessary (distance becomes too large) - * reduces the cache to 4 points, when more then 4 points are added, using following rules: - * the contact point with deepest penetration is always kept, and it tries to maximuze the area covered by the points - * note that some pairs of objects might have more then one contact manifold. */ -@Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) -public class b3ContactCache extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public b3ContactCache() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public b3ContactCache(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public b3ContactCache(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public b3ContactCache position(long position) { - return (b3ContactCache)super.position(position); - } - @Override public b3ContactCache getPointer(long i) { - return new b3ContactCache((Pointer)this).offsetAddress(i); - } - - - public native int addManifoldPoint(@Const @ByRef b3Vector3 newPoint); - - /*void replaceContactPoint(const b3Vector3& newPoint,int insertIndex) - { - b3Assert(validContactDistance(newPoint)); - m_pointCache[insertIndex] = newPoint; - } - */ - - public static native @Cast("bool") boolean validContactDistance(@Const @ByRef b3Vector3 pt); - - /** calculated new worldspace coordinates and depth, and reject points that exceed the collision margin */ - public static native void refreshContactPoints(@Const @ByRef b3Transform trA, @Const @ByRef b3Transform trB, @ByRef b3Contact4Data newContactCache); - - public static native void removeContactPoint(@ByRef b3Contact4Data newContactCache, int i); -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java index c17df9e2a3d..c35a4dfa8fa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java @@ -46,9 +46,7 @@ public class b3GpuNarrowPhase extends Pointer { public native int registerRigidBody(int collidableIndex, float mass, @Const FloatPointer _position, @Const FloatPointer orientation, @Const FloatPointer aabbMin, @Const FloatPointer aabbMax, @Cast("bool") boolean writeToGpu); public native int registerRigidBody(int collidableIndex, float mass, @Const FloatBuffer _position, @Const FloatBuffer orientation, @Const FloatBuffer aabbMin, @Const FloatBuffer aabbMax, @Cast("bool") boolean writeToGpu); public native int registerRigidBody(int collidableIndex, float mass, @Const float[] _position, @Const float[] orientation, @Const float[] aabbMin, @Const float[] aabbMax, @Cast("bool") boolean writeToGpu); - public native void setObjectTransform(@Const FloatPointer _position, @Const FloatPointer orientation, int bodyIndex); - public native void setObjectTransform(@Const FloatBuffer _position, @Const FloatBuffer orientation, int bodyIndex); - public native void setObjectTransform(@Const float[] _position, @Const float[] orientation, int bodyIndex); + public native void writeAllBodiesToGpu(); public native void reset(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java index ef333b93211..1668aa0bdbe 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java @@ -30,7 +30,7 @@ public class b3GpuRigidBodyPipeline extends Pointer { public native void integrate(float timeStep); public native void setupGpuAabbsFull(); - public native int registerConvexPolyhedron(b3ConvexUtility convex); + //int registerConvexPolyhedron(const float* vertices, int strideInBytes, int numVertices, const float* scaling); //int registerSphereShape(float radius); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java index ef5766d47b0..4cc6ee02130 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java @@ -40,9 +40,7 @@ public class b3LauncherCL extends Pointer { public native int deserializeArgs(@Cast("unsigned char*") ByteBuffer buf, int bufSize, @ByVal cl_context ctx); public native int deserializeArgs(@Cast("unsigned char*") byte[] buf, int bufSize, @ByVal cl_context ctx); - public native int validateResults(@Cast("unsigned char*") BytePointer goldBuffer, int goldBufferCapacity, @ByVal cl_context ctx); - public native int validateResults(@Cast("unsigned char*") ByteBuffer goldBuffer, int goldBufferCapacity, @ByVal cl_context ctx); - public native int validateResults(@Cast("unsigned char*") byte[] goldBuffer, int goldBufferCapacity, @ByVal cl_context ctx); + public native int serializeArguments(@Cast("unsigned char*") BytePointer destBuffer, int destBufferCapacity); public native int serializeArguments(@Cast("unsigned char*") ByteBuffer destBuffer, int destBufferCapacity); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java index 062b44487f6..13affa6bec1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java @@ -560,42 +560,6 @@ public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL { // #endif //B3_BVH_INFO_H -// Parsed from Bullet3OpenCL/NarrowphaseCollision/b3ContactCache.h - - -/* -Bullet Continuous Collision Detection and Physics Library -Copyright (c) 2003-2013 Erwin Coumans http://bulletphysics.org - -This software is provided 'as-is', without any express or implied warranty. -In no event will the authors be held liable for any damages arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it freely, -subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. -2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. -3. This notice may not be removed or altered from any source distribution. -*/ - -// #ifndef B3_CONTACT_CACHE_H -// #define B3_CONTACT_CACHE_H - -// #include "Bullet3Common/b3Vector3.h" -// #include "Bullet3Common/b3Transform.h" -// #include "Bullet3Common/b3AlignedAllocator.h" - -/**maximum contact breaking and merging threshold */ -public static native @Cast("b3Scalar") float gContactBreakingThreshold(); public static native void gContactBreakingThreshold(float setter); - -public static final int MANIFOLD_CACHE_SIZE = 4; -// Targeting ../Bullet3OpenCL/b3ContactCache.java - - - -// #endif //B3_CONTACT_CACHE_H - - // Parsed from Bullet3OpenCL/NarrowphaseCollision/b3ConvexHullContact.h From 8df5786645599fba5bfcd3627530c7cb17405f73 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 14 Mar 2022 00:00:22 +0800 Subject: [PATCH 71/81] Fix building bullet preset on windows platform --- .../java/org/bytedeco/bullet/presets/Bullet3Collision.java | 4 ++-- .../java/org/bytedeco/bullet/presets/Bullet3Dynamics.java | 1 - 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java index 7ca9f78f618..11a82ca59b7 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java @@ -62,10 +62,10 @@ "Bullet3Collision/NarrowPhaseCollision/shared/b3MprPenetration.h", "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h", "Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h", - "Bullet3Collision/NarrowPhaseCollision/shared/b3UpdateAabbs.h", }, link = "Bullet3Collision@.3.20" - ) + ), + @Platform(value = "windows", link = { "Bullet3Collision@.3.20", "Bullet3Geometry@.3.20" }) }, target = "org.bytedeco.bullet.Bullet3Collision", global = "org.bytedeco.bullet.global.Bullet3Collision" diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java index 04b869c43c4..649e38c6b85 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Dynamics.java @@ -50,7 +50,6 @@ "Bullet3Dynamics/ConstraintSolver/b3PgsJacobiSolver.h", "Bullet3Dynamics/ConstraintSolver/b3Point2PointConstraint.h", "Bullet3Dynamics/shared/b3ContactConstraint4.h", - "Bullet3Dynamics/shared/b3ConvertConstraint4.h", "Bullet3Dynamics/shared/b3Inertia.h", "Bullet3Dynamics/shared/b3IntegrateTransforms.h", "Bullet3Dynamics/b3CpuRigidBodyPipeline.h", From 3004790bdf5425b74d5484ff947cda28bc573e03 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 14 Mar 2022 00:07:59 +0800 Subject: [PATCH 72/81] Update generated code of bullet preset See parent commit. --- bullet/cppbuild.sh | 2 +- .../bullet/global/Bullet3Collision.java | 14 ----------- .../bullet/global/Bullet3Dynamics.java | 24 ------------------- 3 files changed, 1 insertion(+), 39 deletions(-) diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh index 3b368f9ade4..e72099be73f 100755 --- a/bullet/cppbuild.sh +++ b/bullet/cppbuild.sh @@ -14,7 +14,7 @@ mkdir -p $PLATFORM cd $PLATFORM INSTALL_PATH=`pwd` echo "Decompressing archives..." -# unzip -qo ../bullet-$BULLET_VERSION.zip +unzip -qo ../bullet-$BULLET_VERSION.zip cd bullet3-$BULLET_VERSION mkdir -p build cd build diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java index 5f518bdf0bb..988ed2d2266 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Collision.java @@ -1236,18 +1236,4 @@ public static native int b3TestQuantizedAabbAgainstQuantizedAabbSlow( // #endif //B3_REDUCE_CONTACTS_H -// Parsed from Bullet3Collision/NarrowPhaseCollision/shared/b3UpdateAabbs.h - -// #ifndef B3_UPDATE_AABBS_H -// #define B3_UPDATE_AABBS_H - -// #include "Bullet3Collision/BroadPhaseCollision/shared/b3Aabb.h" -// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Collidable.h" -// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" - -public static native void b3ComputeWorldAabb(int bodyId, @Const b3RigidBodyData bodies, @Const b3Collidable collidables, @Const b3Aabb localShapeAABB, b3Aabb worldAabbs); - -// #endif //B3_UPDATE_AABBS_H - - } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java index f9de9dfbe65..36fabdd5c50 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3Dynamics.java @@ -465,30 +465,6 @@ public class Bullet3Dynamics extends org.bytedeco.bullet.presets.Bullet3Dynamics // #endif //B3_CONTACT_CONSTRAINT5_H -// Parsed from Bullet3Dynamics/shared/b3ConvertConstraint4.h - - - -// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3Contact4Data.h" -// #include "Bullet3Dynamics/shared/b3ContactConstraint4.h" -// #include "Bullet3Collision/NarrowPhaseCollision/shared/b3RigidBodyData.h" - -public static native void b3PlaneSpace1(@Const @ByRef b3Vector3 n, b3Vector3 p, b3Vector3 q); - -public static native void setLinearAndAngular(@Const @ByRef b3Vector3 n, @Const @ByRef b3Vector3 r0, @Const @ByRef b3Vector3 r1, b3Vector3 linear, b3Vector3 angular0, b3Vector3 angular1); - -public static native float calcRelVel(@Const @ByRef b3Vector3 l0, @Const @ByRef b3Vector3 l1, @Const @ByRef b3Vector3 a0, @Const @ByRef b3Vector3 a1, @Const @ByRef b3Vector3 linVel0, - @Const @ByRef b3Vector3 angVel0, @Const @ByRef b3Vector3 linVel1, @Const @ByRef b3Vector3 angVel1); - -public static native float calcJacCoeff(@Const @ByRef b3Vector3 linear0, @Const @ByRef b3Vector3 linear1, @Const @ByRef b3Vector3 angular0, @Const @ByRef b3Vector3 angular1, - float invMass0, @Const b3Matrix3x3 invInertia0, float invMass1, @Const b3Matrix3x3 invInertia1); - -public static native void setConstraint4(@Const @ByRef b3Vector3 posA, @Const @ByRef b3Vector3 linVelA, @Const @ByRef b3Vector3 angVelA, float invMassA, @Const @ByRef b3Matrix3x3 invInertiaA, - @Const @ByRef b3Vector3 posB, @Const @ByRef b3Vector3 linVelB, @Const @ByRef b3Vector3 angVelB, float invMassB, @Const @ByRef b3Matrix3x3 invInertiaB, - b3Contact4Data src, float dt, float positionDrift, float positionConstraintCoeff, - b3ContactConstraint4 dstC); - - // Parsed from Bullet3Dynamics/shared/b3Inertia.h From 5c2db3760873a9b3868ea619103e01751bab35fe Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Mon, 14 Mar 2022 00:22:54 +0800 Subject: [PATCH 73/81] Allow bullet preset use istalled headers Use installed headers for generating mappings and keep `bullet3/src` path for discovery of `clew` headers. --- bullet/pom.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/bullet/pom.xml b/bullet/pom.xml index 5760bcdacf7..d5b27b3d420 100644 --- a/bullet/pom.xml +++ b/bullet/pom.xml @@ -34,6 +34,7 @@ javacpp + ${basedir}/cppbuild/${javacpp.platform}/include/bullet ${basedir}/cppbuild/${javacpp.platform}/bullet3-3.21/src From 2f2b64cedbfef6dcfe495fc258fc7c425862996f Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 16 Mar 2022 22:06:06 +0800 Subject: [PATCH 74/81] Ignore python cache --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index ac17fa0deb2..62b9bce9162 100644 --- a/.gitignore +++ b/.gitignore @@ -15,3 +15,6 @@ # IntelliJ *.iml .idea + +# Python +__pycache__ From 8d294c9275272bfa3d37457716f9244e5f17f0bf Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 16 Mar 2022 22:39:18 +0800 Subject: [PATCH 75/81] Mappings of bullet's clew library --- bullet/gen-clew-stubs | 84 +++++++++ bullet/pom.xml | 1 + .../bullet/presets/Bullet3OpenCL.java | 53 +----- .../org/bytedeco/bullet/presets/clew.java | 172 ++++++++++++++++++ bullet/src/main/java9/module-info.java | 1 + .../org/bytedeco/bullet/include/clew_stubs.h | 120 ++++++++++++ 6 files changed, 379 insertions(+), 52 deletions(-) create mode 100755 bullet/gen-clew-stubs create mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/clew.java create mode 100644 bullet/src/main/resources/org/bytedeco/bullet/include/clew_stubs.h diff --git a/bullet/gen-clew-stubs b/bullet/gen-clew-stubs new file mode 100755 index 00000000000..2a173b8a6a4 --- /dev/null +++ b/bullet/gen-clew-stubs @@ -0,0 +1,84 @@ +#!/usr/bin/env hy + +;; +;; Copyright (C) 2022 Andrey Krainyak +;; +;; Licensed either under the Apache License, Version 2.0, or (at your option) +;; under the terms of the GNU General Public License as published by +;; the Free Software Foundation (subject to the "Classpath" exception), +;; either version 2, or any later version (collectively, the "License"); +;; you may not use this file except in compliance with the License. +;; You may obtain a copy of the License at +;; +;; http://www.apache.org/licenses/LICENSE-2.0 +;; http://www.gnu.org/licenses/ +;; http://www.gnu.org/software/classpath/license.html +;; +;; or as provided in the LICENSE.txt file that accompanied this code. +;; Unless required by applicable law or agreed to in writing, software +;; distributed under the License is distributed on an "AS IS" BASIS, +;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +;; See the License for the specific language governing permissions and +;; limitations under the License. +;; + + + +;; Usage: + +;; Install dependencies: pip install --pre hy hyrule +;; Invoke the script from terminal - it will spit out the stubs into stdout. +;; Copy the output into clew_stubs.h inside bullet/src/main/resources. + +(import glob [glob]) +(import pathlib [Path]) +(import re) +(require hyrule [-> ->>] + hyrule.anaphoric * + hyrule.destructure [let+]) + +(setv SCRIPT-PATH (Path __file__)) +(setv BULLET-DIR (. SCRIPT-PATH parent)) +(setv CLEW-H-PATH (get (glob f"{BULLET-DIR}/**/clew.h" :recursive True) 0)) + +(defn read-header [] + (with [f (open CLEW-H-PATH "r")] + (f.read))) + +(defn extract-func-names [header-text] + (->> header-text + (re.findall "#define *(\w+) *CLEW_GET_FUN.*\n"))) + +(defn parse-params [text] + (->> text + (re.sub "[\n\t]" " ") + (re.sub " +" " "))) + +(defn parse-typedef [text] + (let [groups (re.search (+ "(?s)CL_API_ENTRY *" + "(?P\w+).*" + "(?PPFN\w+)\)" + "\((?P.*)\)") text)] + (, (.group groups "pfn") + {"params" (parse-params (.group groups "params")) + "ret-type" (.group groups "rettype")}))) + +(defn extract-typedefs [header-text] + (->> header-text + (re.findall "(?s)typedef CL_API_ENTRY.*?;") + (map parse-typedef) + dict)) + +(defn gen-fun-decl [name typedefs] + (let+ [pfn (+ "PFN" (.upper name)) + {ret "ret-type" ps "params"} (get typedefs pfn)] + f"{ret} {name}({ps});")) + +(let [header-text (read-header) + typedefs (extract-typedefs header-text)] + (->> header-text + extract-func-names + sorted + (map #%(gen-fun-decl %1 typedefs)) + (.join "\n") + print)) diff --git a/bullet/pom.xml b/bullet/pom.xml index d5b27b3d420..12e2af5b8c7 100644 --- a/bullet/pom.xml +++ b/bullet/pom.xml @@ -36,6 +36,7 @@ ${basedir}/cppbuild/${javacpp.platform}/include/bullet ${basedir}/cppbuild/${javacpp.platform}/bullet3-3.21/src + ${basedir}/target/classes/org/bytedeco/${javacpp.packageName}/include/ diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java index e67ca51fdb1..2c662ec1b7e 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java @@ -36,7 +36,7 @@ * @author Andrey Krainyak */ @Properties( - inherit = Bullet3Dynamics.class, + inherit = {Bullet3Dynamics.class, clew.class}, value = { @Platform( define = { @@ -104,22 +104,6 @@ private static void mapOCLArrays(InfoMap infoMap, String... typeNames) { public void map(InfoMap infoMap) { infoMap - .put(new Info("cl_bool").cppTypes("bool")) - .put(new Info("cl_command_queue").cppTypes("cl_command_queue")) - .put(new Info("cl_command_queue_properties").cppTypes("int")) - .put(new Info("cl_context").pointerTypes("cl_context")) - .put(new Info("cl_device_id").pointerTypes("cl_device_id")) - .put(new Info("cl_device_local_mem_type").cppTypes("int")) - .put(new Info("cl_device_type").cppTypes("int")) - .put(new Info("cl_int").cppTypes("int")) - .put(new Info("cl_kernel").pointerTypes("cl_kernel")) - .put(new Info("cl_long").cppTypes("long")) - .put(new Info("cl_mem").pointerTypes("cl_mem")) - .put(new Info("cl_platform_id").pointerTypes("cl_platform_id")) - .put(new Info("cl_program").pointerTypes("cl_program")) - .put(new Info("cl_uint").cppTypes("unsigned int")) - .put(new Info("cl_ulong").cppTypes("unsigned long")) - .put(new Info( "DEBUG_CHECK_DEQUANTIZATION", "b3Int64", @@ -208,39 +192,4 @@ public void map(InfoMap infoMap) { "b3Vector3" ); } - - public static class cl_command_queue extends Pointer { - public cl_command_queue() { super((Pointer)null); } - public cl_command_queue(Pointer p) { super(p); } - } - - public static class cl_context extends Pointer { - public cl_context() { super((Pointer)null); } - public cl_context(Pointer p) { super(p); } - } - - public static class cl_device_id extends Pointer { - public cl_device_id() { super((Pointer)null); } - public cl_device_id(Pointer p) { super(p); } - } - - public static class cl_kernel extends Pointer { - public cl_kernel() { super((Pointer)null); } - public cl_kernel(Pointer p) { super(p); } - } - - public static class cl_mem extends Pointer { - public cl_mem() { super((Pointer)null); } - public cl_mem(Pointer p) { super(p); } - } - - public static class cl_platform_id extends Pointer { - public cl_platform_id() { super((Pointer)null); } - public cl_platform_id(Pointer p) { super(p); } - } - - public static class cl_program extends Pointer { - public cl_program() { super((Pointer)null); } - public cl_program(Pointer p) { super(p); } - } } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/clew.java b/bullet/src/main/java/org/bytedeco/bullet/presets/clew.java new file mode 100644 index 00000000000..7300ae27ac3 --- /dev/null +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/clew.java @@ -0,0 +1,172 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.bytedeco.bullet.presets; + +import org.bytedeco.javacpp.Loader; +import org.bytedeco.javacpp.Pointer; +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.presets.javacpp; +import org.bytedeco.javacpp.tools.Info; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +/** + * + * @author Andrey Krainyak + */ +@Properties( + inherit = javacpp.class, + value = { + @Platform( + include = { + "clew/clew.h", + "clew_stubs.h", + }, + link = "Bullet3OpenCL_clew@.3.20" + ) + }, + target = "org.bytedeco.bullet.clew" +) +public class clew implements InfoMapper { + static { Loader.checkVersion("org.bytedeco", "bullet"); } + + public void map(InfoMap infoMap) { + infoMap + .put(new Info("cl_bool").cppTypes("bool")) + .put(new Info("cl_int").cppTypes("int")) + .put(new Info("cl_long").cppTypes("long")) + .put(new Info("cl_uint").cppTypes("unsigned int")) + .put(new Info("cl_ulong").cppTypes("unsigned long")) + + .put(new Info( + "CL_HUGE_VAL", + "CL_PROGRAM_STRING_DEBUG_INFO" + ).cppTypes().translate(false)) + + .put(new Info( + "(defined(_WIN32) && defined(_MSC_VER))", + "__APPLE1__", + "defined(CL_NAMED_STRUCT_SUPPORTED) && defined(_MSC_VER)", + "defined(CL_NAMED_STRUCT_SUPPORTED)", + "defined(_WIN32)", + "defined(__AVX__)", + "defined(__GNUC__)", + "defined(__MMX__)", + "defined(__SSE2__)", + "defined(__SSE__)", + "defined(__VEC__)", + "defined(__cl_uchar2__)" + ).define(false)) + + .put(new Info("cl_command_queue").pointerTypes("cl_command_queue")) + .put(new Info("cl_context").pointerTypes("cl_context")) + .put(new Info("cl_device_id").pointerTypes("cl_device_id")) + .put(new Info("cl_event").pointerTypes("cl_event")) + .put(new Info("cl_kernel").pointerTypes("cl_kernel")) + .put(new Info("cl_mem").pointerTypes("cl_mem")) + .put(new Info("cl_platform_id").pointerTypes("cl_platform_id")) + .put(new Info("cl_program").pointerTypes("cl_program")) + .put(new Info("cl_sampler").pointerTypes("cl_sampler")) + + .put(new Info("clew.h").linePatterns( + ".*typedef.*CL_API_ENTRY.*", + "#define clGetExtensionFunctionAddress.*" + ).skip()) + + .put(new Info( + "CL_NAN", + "cl_long2", + "cl_long4", + "cl_long8", + "cl_long16", + "nanf" + ).skip()) + ; + + String[] types = new String[] { + "CHAR", + "UCHAR", + "SHORT", + "USHORT", + "INT", + "UINT", + "LONG", + "ULONG", + "FLOAT", + "DOUBLE", + }; + + for (String type: types) { + for (String size: new String[] { "2", "4", "8", "16" }) { + infoMap.put(new Info( + "defined(__CL_" + type + size + "__)").define(false)); + } + } + } + + public static class cl_command_queue extends Pointer { + public cl_command_queue() { super((Pointer)null); } + public cl_command_queue(Pointer p) { super(p); } + } + + public static class cl_context extends Pointer { + public cl_context() { super((Pointer)null); } + public cl_context(Pointer p) { super(p); } + } + + public static class cl_device_id extends Pointer { + public cl_device_id() { super((Pointer)null); } + public cl_device_id(Pointer p) { super(p); } + } + + public static class cl_event extends Pointer { + public cl_event() { super((Pointer)null); } + public cl_event(Pointer p) { super(p); } + } + + public static class cl_kernel extends Pointer { + public cl_kernel() { super((Pointer)null); } + public cl_kernel(Pointer p) { super(p); } + } + + public static class cl_mem extends Pointer { + public cl_mem() { super((Pointer)null); } + public cl_mem(Pointer p) { super(p); } + } + + public static class cl_platform_id extends Pointer { + public cl_platform_id() { super((Pointer)null); } + public cl_platform_id(Pointer p) { super(p); } + } + + public static class cl_program extends Pointer { + public cl_program() { super((Pointer)null); } + public cl_program(Pointer p) { super(p); } + } + + public static class cl_sampler extends Pointer { + public cl_sampler() { super((Pointer)null); } + public cl_sampler(Pointer p) { super(p); } + } +} diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 18a42688a5e..95308a14fab 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -1,5 +1,6 @@ module org.bytedeco.bullet { requires transitive org.bytedeco.javacpp; + exports org.bytedeco.bullet.clew; exports org.bytedeco.bullet.global; exports org.bytedeco.bullet.presets; exports org.bytedeco.bullet.LinearMath; diff --git a/bullet/src/main/resources/org/bytedeco/bullet/include/clew_stubs.h b/bullet/src/main/resources/org/bytedeco/bullet/include/clew_stubs.h new file mode 100644 index 00000000000..64b57efb54f --- /dev/null +++ b/bullet/src/main/resources/org/bytedeco/bullet/include/clew_stubs.h @@ -0,0 +1,120 @@ +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + + +// This #ifdef disables these stubs during native code compilation, +// as the stubs should be used for generation of the Java-side +// code only, and the native code should use the original definitions +// provided by clew's header. +#ifdef XXXXXXXXXX + +using BuildProgramCallback = void (*)(cl_program, void*); +cl_int clBuildProgram(cl_program /* program */, cl_uint /* num_devices */, const cl_device_id * /* device_list */, const char * /* options */, BuildProgramCallback, void * /* user_data */); + +using CreateContextCallback = void (*)(const char*, const void*, size_t, void*); +cl_context clCreateContext(const cl_context_properties * /* properties */, cl_uint /* num_devices */, const cl_device_id * /* devices */, CreateContextCallback, void * /* user_data */, cl_int * /* errcode_ret */); +cl_context clCreateContextFromType(const cl_context_properties * /* properties */, cl_device_type /* device_type */, CreateContextCallback, void * /* user_data */, cl_int * /* errcode_ret */); + +using EnqueueNativeKernelCallback = void (*)(void*); +cl_int clEnqueueNativeKernel(cl_command_queue /* command_queue */, EnqueueNativeKernelCallback, void * /* args */, size_t /* cb_args */, cl_uint /* num_mem_objects */, const cl_mem * /* mem_list */, const void ** /* args_mem_loc */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); + +using EventCallback = void (*)(cl_event, cl_int, void*); +cl_int clSetEventCallback(cl_event /* event */, cl_int /* command_exec_callback_type */, EventCallback, void * /* user_data */); + +using MemObjectDestructorCallback = void (*)(cl_mem, void*); +cl_int clSetMemObjectDestructorCallback(cl_mem /* memobj */, MemObjectDestructorCallback, void * /*user_data */); + +/*************************************************************************** + Generated with bullet/gen-clew-stubs script +***************************************************************************/ + +cl_mem clCreateBuffer(cl_context /* context */, cl_mem_flags /* flags */, size_t /* size */, void * /* host_ptr */, cl_int * /* errcode_ret */); +cl_command_queue clCreateCommandQueue(cl_context /* context */, cl_device_id /* device */, cl_command_queue_properties /* properties */, cl_int * /* errcode_ret */); +cl_mem clCreateImage2D(cl_context /* context */, cl_mem_flags /* flags */, const cl_image_format * /* image_format */, size_t /* image_width */, size_t /* image_height */, size_t /* image_row_pitch */, void * /* host_ptr */, cl_int * /* errcode_ret */); +cl_mem clCreateImage3D(cl_context /* context */, cl_mem_flags /* flags */, const cl_image_format * /* image_format */, size_t /* image_width */, size_t /* image_height */, size_t /* image_depth */, size_t /* image_row_pitch */, size_t /* image_slice_pitch */, void * /* host_ptr */, cl_int * /* errcode_ret */); +cl_kernel clCreateKernel(cl_program /* program */, const char * /* kernel_name */, cl_int * /* errcode_ret */); +cl_int clCreateKernelsInProgram(cl_program /* program */, cl_uint /* num_kernels */, cl_kernel * /* kernels */, cl_uint * /* num_kernels_ret */); +cl_program clCreateProgramWithBinary(cl_context /* context */, cl_uint /* num_devices */, const cl_device_id * /* device_list */, const size_t * /* lengths */, const unsigned char ** /* binaries */, cl_int * /* binary_status */, cl_int * /* errcode_ret */); +cl_program clCreateProgramWithSource(cl_context /* context */, cl_uint /* count */, const char ** /* strings */, const size_t * /* lengths */, cl_int * /* errcode_ret */); +cl_sampler clCreateSampler(cl_context /* context */, cl_bool /* normalized_coords */, cl_addressing_mode /* addressing_mode */, cl_filter_mode /* filter_mode */, cl_int * /* errcode_ret */); +cl_mem clCreateSubBuffer(cl_mem /* buffer */, cl_mem_flags /* flags */, cl_buffer_create_type /* buffer_create_type */, const void * /* buffer_create_info */, cl_int * /* errcode_ret */); +cl_event clCreateUserEvent(cl_context /* context */, cl_int * /* errcode_ret */); +cl_int clEnqueueBarrier(cl_command_queue /* command_queue */); +cl_int clEnqueueCopyBuffer(cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_buffer */, size_t /* src_offset */, size_t /* dst_offset */, size_t /* cb */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueCopyBufferRect(cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_buffer */, const size_t * /* src_origin */, const size_t * /* dst_origin */, const size_t * /* region */, size_t /* src_row_pitch */, size_t /* src_slice_pitch */, size_t /* dst_row_pitch */, size_t /* dst_slice_pitch */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueCopyBufferToImage(cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_image */, size_t /* src_offset */, const size_t * /* dst_origin[3] */, const size_t * /* region[3] */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueCopyImage(cl_command_queue /* command_queue */, cl_mem /* src_image */, cl_mem /* dst_image */, const size_t * /* src_origin[3] */, const size_t * /* dst_origin[3] */, const size_t * /* region[3] */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueCopyImageToBuffer(cl_command_queue /* command_queue */, cl_mem /* src_image */, cl_mem /* dst_buffer */, const size_t * /* src_origin[3] */, const size_t * /* region[3] */, size_t /* dst_offset */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +void clEnqueueMapBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_map */, cl_map_flags /* map_flags */, size_t /* offset */, size_t /* cb */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */, cl_int * /* errcode_ret */); +void clEnqueueMapImage(cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_map */, cl_map_flags /* map_flags */, const size_t * /* origin[3] */, const size_t * /* region[3] */, size_t * /* image_row_pitch */, size_t * /* image_slice_pitch */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */, cl_int * /* errcode_ret */); +cl_int clEnqueueMarker(cl_command_queue /* command_queue */, cl_event * /* event */); +cl_int clEnqueueNDRangeKernel(cl_command_queue /* command_queue */, cl_kernel /* kernel */, cl_uint /* work_dim */, const size_t * /* global_work_offset */, const size_t * /* global_work_size */, const size_t * /* local_work_size */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueReadBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */, size_t /* offset */, size_t /* cb */, void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueReadBufferRect(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */, const size_t * /* buffer_origin */, const size_t * /* host_origin */, const size_t * /* region */, size_t /* buffer_row_pitch */, size_t /* buffer_slice_pitch */, size_t /* host_row_pitch */, size_t /* host_slice_pitch */, void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueReadImage(cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_read */, const size_t * /* origin[3] */, const size_t * /* region[3] */, size_t /* row_pitch */, size_t /* slice_pitch */, void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueTask(cl_command_queue /* command_queue */, cl_kernel /* kernel */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueUnmapMemObject(cl_command_queue /* command_queue */, cl_mem /* memobj */, void * /* mapped_ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueWaitForEvents(cl_command_queue /* command_queue */, cl_uint /* num_events */, const cl_event * /* event_list */); +cl_int clEnqueueWriteBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_write */, size_t /* offset */, size_t /* cb */, const void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueWriteBufferRect(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_write */, const size_t * /* buffer_origin */, const size_t * /* host_origin */, const size_t * /* region */, size_t /* buffer_row_pitch */, size_t /* buffer_slice_pitch */, size_t /* host_row_pitch */, size_t /* host_slice_pitch */, const void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clEnqueueWriteImage(cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_write */, const size_t * /* origin[3] */, const size_t * /* region[3] */, size_t /* input_row_pitch */, size_t /* input_slice_pitch */, const void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); +cl_int clFinish(cl_command_queue /* command_queue */); +cl_int clFlush(cl_command_queue /* command_queue */); +cl_int clGetCommandQueueInfo(cl_command_queue /* command_queue */, cl_command_queue_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetContextInfo(cl_context /* context */, cl_context_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetDeviceIDs(cl_platform_id /* platform */, cl_device_type /* device_type */, cl_uint /* num_entries */, cl_device_id * /* devices */, cl_uint * /* num_devices */); +cl_int clGetDeviceInfo(cl_device_id /* device */, cl_device_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetEventInfo(cl_event /* event */, cl_event_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetEventProfilingInfo(cl_event /* event */, cl_profiling_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +void clGetExtensionFunctionAddress(const char * /* func_name */); +cl_int clGetImageInfo(cl_mem /* image */, cl_image_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetKernelInfo(cl_kernel /* kernel */, cl_kernel_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetKernelWorkGroupInfo(cl_kernel /* kernel */, cl_device_id /* device */, cl_kernel_work_group_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetMemObjectInfo(cl_mem /* memobj */, cl_mem_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetPlatformIDs(cl_uint /* num_entries */, cl_platform_id * /* platforms */, cl_uint * /* num_platforms */); +cl_int clGetPlatformInfo(cl_platform_id /* platform */, cl_platform_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetProgramBuildInfo(cl_program /* program */, cl_device_id /* device */, cl_program_build_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetProgramInfo(cl_program /* program */, cl_program_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetSamplerInfo(cl_sampler /* sampler */, cl_sampler_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); +cl_int clGetSupportedImageFormats(cl_context /* context */, cl_mem_flags /* flags */, cl_mem_object_type /* image_type */, cl_uint /* num_entries */, cl_image_format * /* image_formats */, cl_uint * /* num_image_formats */); +cl_int clReleaseCommandQueue(cl_command_queue /* command_queue */); +cl_int clReleaseContext(cl_context /* context */); +cl_int clReleaseEvent(cl_event /* event */); +cl_int clReleaseKernel(cl_kernel /* kernel */); +cl_int clReleaseMemObject(cl_mem /* memobj */); +cl_int clReleaseProgram(cl_program /* program */); +cl_int clReleaseSampler(cl_sampler /* sampler */); +cl_int clRetainCommandQueue(cl_command_queue /* command_queue */); +cl_int clRetainContext(cl_context /* context */); +cl_int clRetainEvent(cl_event /* event */); +cl_int clRetainKernel(cl_kernel /* kernel */); +cl_int clRetainMemObject(cl_mem /* memobj */); +cl_int clRetainProgram(cl_program /* program */); +cl_int clRetainSampler(cl_sampler /* sampler */); +// cl_int clSetCommandQueueProperty(cl_command_queue /* command_queue */, cl_command_queue_properties /* properties */, cl_bool /* enable */, cl_command_queue_properties * /* old_properties */); +cl_int clSetKernelArg(cl_kernel /* kernel */, cl_uint /* arg_index */, size_t /* arg_size */, const void * /* arg_value */); +cl_int clSetUserEventStatus(cl_event /* event */, cl_int /* execution_status */); +cl_int clUnloadCompiler(void); +cl_int clWaitForEvents(cl_uint /* num_events */, const cl_event * /* event_list */); + +#endif // XXXXXXXXXX From e2d246e367e3a9a5f06223dacc6ed7b46ce3b31a Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Wed, 16 Mar 2022 22:39:52 +0800 Subject: [PATCH 76/81] Update generated code of bullet preset --- .../bullet/Bullet3OpenCL/GpuSatCollision.java | 1 + .../bullet/Bullet3OpenCL/b3AabbOCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3BoundSearchCL.java | 1 + .../bullet/Bullet3OpenCL/b3BufferInfoCL.java | 1 + .../bullet/Bullet3OpenCL/b3BvhInfo.java | 1 + .../bullet/Bullet3OpenCL/b3BvhInfoArray.java | 1 + .../Bullet3OpenCL/b3BvhInfoOCLArray.java | 1 + .../Bullet3OpenCL/b3BvhSubtreeInfo.java | 1 + .../Bullet3OpenCL/b3BvhSubtreeInfoArray.java | 1 + .../b3BvhSubtreeInfoOCLArray.java | 1 + .../Bullet3OpenCL/b3CharIndexTripletData.java | 1 + .../Bullet3OpenCL/b3CollidableOCLArray.java | 1 + .../b3CompoundOverlappingPairArray.java | 1 + .../b3CompoundOverlappingPairOCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3Contact4Array.java | 1 + .../Bullet3OpenCL/b3Contact4OCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3ContactPoint.java | 1 + .../b3ConvexPolyhedronDataOCLArray.java | 1 + .../Bullet3OpenCL/b3ConvexUtilityArray.java | 1 + .../bullet/Bullet3OpenCL/b3Dispatcher.java | 1 + .../bullet/Bullet3OpenCL/b3FillCL.java | 1 + .../bullet/Bullet3OpenCL/b3FloatOCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3GjkEpaSolver2.java | 1 + .../Bullet3OpenCL/b3GjkPairDetector.java | 1 + .../b3GpuBroadphaseInterface.java | 1 + .../b3GpuChildShapeOCLArray.java | 1 + .../Bullet3OpenCL/b3GpuConstraint4.java | 1 + .../Bullet3OpenCL/b3GpuConstraint4Array.java | 1 + .../b3GpuConstraint4OCLArray.java | 1 + .../Bullet3OpenCL/b3GpuConstraintInfo2.java | 1 + .../Bullet3OpenCL/b3GpuFaceOCLArray.java | 1 + .../Bullet3OpenCL/b3GpuGenericConstraint.java | 1 + .../b3GpuGenericConstraintArray.java | 1 + .../b3GpuGenericConstraintOCLArray.java | 1 + .../Bullet3OpenCL/b3GpuGridBroadphase.java | 1 + .../b3GpuJacobiContactSolver.java | 1 + .../Bullet3OpenCL/b3GpuNarrowPhase.java | 1 + .../b3GpuNarrowPhaseInternalData.java | 1 + .../Bullet3OpenCL/b3GpuParallelLinearBvh.java | 1 + .../b3GpuParallelLinearBvhBroadphase.java | 1 + .../b3GpuPgsConstraintSolver.java | 1 + .../Bullet3OpenCL/b3GpuPgsContactSolver.java | 1 + .../bullet/Bullet3OpenCL/b3GpuRaycast.java | 1 + .../Bullet3OpenCL/b3GpuRigidBodyPipeline.java | 1 + .../b3GpuRigidBodyPipelineInternalData.java | 1 + .../Bullet3OpenCL/b3GpuSapBroadphase.java | 1 + .../bullet/Bullet3OpenCL/b3GpuSolverBody.java | 1 + .../Bullet3OpenCL/b3GpuSolverConstraint.java | 1 + .../bullet/Bullet3OpenCL/b3IndexedMesh.java | 1 + .../Bullet3OpenCL/b3InertiaDataArray.java | 1 + .../Bullet3OpenCL/b3InertiaDataOCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3Int2OCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3Int4OCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3IntIndexData.java | 1 + .../bullet/Bullet3OpenCL/b3IntOCLArray.java | 1 + .../b3InternalTriangleIndexCallback.java | 1 + .../Bullet3OpenCL/b3JacobiSolverInfo.java | 1 + .../bullet/Bullet3OpenCL/b3KernelArgData.java | 1 + .../bullet/Bullet3OpenCL/b3LauncherCL.java | 1 + .../bullet/Bullet3OpenCL/b3MeshPartData.java | 1 + .../Bullet3OpenCL/b3NodeOverlapCallback.java | 1 + .../Bullet3OpenCL/b3OpenCLDeviceInfo.java | 7 +- .../Bullet3OpenCL/b3OpenCLPlatformInfo.java | 1 + .../bullet/Bullet3OpenCL/b3OpenCLUtils.java | 25 +- .../bullet/Bullet3OpenCL/b3OptimizedBvh.java | 1 + .../Bullet3OpenCL/b3OptimizedBvhArray.java | 1 + .../Bullet3OpenCL/b3OptimizedBvhNode.java | 1 + .../b3OptimizedBvhNodeDoubleData.java | 1 + .../b3OptimizedBvhNodeFloatData.java | 1 + .../b3ParamsGridBroadphaseCL.java | 1 + .../Bullet3OpenCL/b3PrefixScanFloat4CL.java | 1 + .../bullet/Bullet3OpenCL/b3QuantizedBvh.java | 1 + .../b3QuantizedBvhDoubleData.java | 1 + .../b3QuantizedBvhFloatData.java | 1 + .../Bullet3OpenCL/b3QuantizedBvhNode.java | 1 + .../b3QuantizedBvhNodeArray.java | 1 + .../b3QuantizedBvhNodeOCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3RadixSort32CL.java | 1 + .../Bullet3OpenCL/b3RayInfoOCLArray.java | 1 + .../b3RigidBodyDataOCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3SapAabb.java | 1 + .../bullet/Bullet3OpenCL/b3SapAabbArray.java | 1 + .../Bullet3OpenCL/b3SapAabbOCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3Serializer.java | 1 + .../Bullet3OpenCL/b3ShortIntIndexData.java | 1 + .../b3ShortIntIndexTripletData.java | 1 + .../bullet/Bullet3OpenCL/b3Solver.java | 1 + .../bullet/Bullet3OpenCL/b3SolverBase.java | 1 + .../bullet/Bullet3OpenCL/b3SortData.java | 1 + .../bullet/Bullet3OpenCL/b3SortDataArray.java | 1 + .../Bullet3OpenCL/b3SortDataOCLArray.java | 1 + .../b3StridingMeshInterface.java | 1 + .../b3StridingMeshInterfaceData.java | 1 + .../b3SubSimplexClosestResult.java | 1 + .../Bullet3OpenCL/b3TriangleCallback.java | 1 + .../b3TriangleIndexVertexArray.java | 1 + .../b3TriangleIndexVertexArrayArray.java | 1 + .../Bullet3OpenCL/b3UnsignedCharOCLArray.java | 1 + .../b3UnsignedCharOCLArrayArray.java | 1 + .../Bullet3OpenCL/b3UnsignedIntOCLArray.java | 1 + .../bullet/Bullet3OpenCL/b3UsageBitfield.java | 1 + .../Bullet3OpenCL/b3Vector3OCLArray.java | 1 + .../Bullet3OpenCL/b3VoronoiSimplexSolver.java | 1 + .../gen/java/org/bytedeco/bullet/clew.java | 2015 +++++++++++++++++ .../bytedeco/bullet/global/Bullet3OpenCL.java | 13 +- 105 files changed, 2140 insertions(+), 21 deletions(-) create mode 100644 bullet/src/gen/java/org/bytedeco/bullet/clew.java diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java index 16cb0f62529..53bd4d9e1f1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java index 5c84cdd88c9..f4416e71410 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java index 31794770d39..9539dcdd679 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; //for b3SortData (perhaps move it?) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java index fc5e5d80dbc..dbf0433a3a4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java index 1e052b2c0f6..74936d1d80b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java index 23a74e7cb51..69d62d7f029 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java index 535006b982e..04846dc0d74 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java index b933b2750d1..23e53ac5c5d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java index 7f05bdfcd96..9c760d5d828 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java index a5372661677..e59d13ad67b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java index d4a9ca5d283..f42d49c428a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java index c637cdad564..bee5f4a061d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java index e326e492734..12edc3578b4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java index 6db1da0a04d..211793a1988 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java index df7f91e92f4..078bf9d3b79 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java index 6e64c6f5ced..a94857989fa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java index aa12e14a847..9b2a5c88830 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java index 85db9da7863..dd23a543f9d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java index a7613b9e97b..8198512a9de 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; //for placement new diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java index 05598b353dc..9f265236f7a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java index 0c003a696f6..b016264ce2b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java index ac809b2bd55..7702ddba5ca 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java index de6030f5c5d..05a4528ee42 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java index 8ffac19a80e..58cce78c75a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java index 66c5d8a3a04..31841db25c1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java index c4de65714c8..1405a07d73e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java index 6b2ee80997b..0b3d2b1165b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java index 873335b0203..507cd81fa9d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java index 687a72e4771..b57a801275c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java index f50a69712fa..9ba572c968b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java index c1e2b32d398..35085c9d7bc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java index 4c39352fd3b..9731bfe5d33 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java index f6ad175ab5a..0d10d309137 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java index 14790e93390..157a1384e8b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java index 6cb804b3a50..65b2d68ddb7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java index 90d5fef71b3..1392d8a3cf4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java index c35a4dfa8fa..7f74823fdc0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java index ba02eb17354..3fc1e13b057 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java index 246038becff..9b9350e3dd4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java index 30746bd693f..a23d8a636e3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java index 1c1902d68b8..2bd59e72d56 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java index 5831d7d4bb6..d647770fb61 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java index 6c058ff2397..4ccb4604a24 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java index 1668aa0bdbe..3fa4d001d98 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java index 48b26ceb215..046e1bac5cd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java index d3c36f5898a..e911386f7a6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java index 8c1625335c8..14d29245034 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java index 037a99b916d..dc001d1b5be 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java index 7c5ba118258..ad73f7acdaf 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java index f506faa6391..1733031d970 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java index f0f486f36c8..3736b050668 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java index 47ed112f106..1bafd00fcae 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java index 3401f745a2a..401f8c89f31 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java index 39db1c42412..ae14ffacd71 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java index 22edaf85c40..d2200f3e266 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java index 72ac26cb20f..9e5e11c3999 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java index c6a44eafecd..9d6baf9814f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java index 2f67242fa74..522c535004a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java index 4cc6ee02130..dee74f94dac 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java index 79877fe441e..d81797d482a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java index d1d1c60e50e..20ddeaa6878 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java index 4d07644d3f3..b47be620923 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -44,7 +45,7 @@ public class b3OpenCLDeviceInfo extends Pointer { public native @Cast("char") byte m_deviceExtensions(int i); public native b3OpenCLDeviceInfo m_deviceExtensions(int i, byte setter); @MemberGetter public native @Cast("char*") BytePointer m_deviceExtensions(); - public native int m_deviceType(); public native b3OpenCLDeviceInfo m_deviceType(int setter); + public native @Cast("cl_device_type") long m_deviceType(); public native b3OpenCLDeviceInfo m_deviceType(long setter); public native @Cast("unsigned int") int m_computeUnits(); public native b3OpenCLDeviceInfo m_computeUnits(int setter); public native @Cast("size_t") long m_workitemDims(); public native b3OpenCLDeviceInfo m_workitemDims(long setter); public native @Cast("size_t") long m_workItemSize(int i); public native b3OpenCLDeviceInfo m_workItemSize(int i, long setter); @@ -60,13 +61,13 @@ public class b3OpenCLDeviceInfo extends Pointer { public native @Cast("unsigned long") long m_localMemSize(); public native b3OpenCLDeviceInfo m_localMemSize(long setter); public native @Cast("unsigned long") long m_globalMemSize(); public native b3OpenCLDeviceInfo m_globalMemSize(long setter); public native @Cast("bool") boolean m_errorCorrectionSupport(); public native b3OpenCLDeviceInfo m_errorCorrectionSupport(boolean setter); - public native int m_localMemType(); public native b3OpenCLDeviceInfo m_localMemType(int setter); + public native @Cast("cl_device_local_mem_type") int m_localMemType(); public native b3OpenCLDeviceInfo m_localMemType(int setter); public native @Cast("unsigned int") int m_maxReadImageArgs(); public native b3OpenCLDeviceInfo m_maxReadImageArgs(int setter); public native @Cast("unsigned int") int m_maxWriteImageArgs(); public native b3OpenCLDeviceInfo m_maxWriteImageArgs(int setter); public native @Cast("unsigned int") int m_addressBits(); public native b3OpenCLDeviceInfo m_addressBits(int setter); public native @Cast("unsigned long") long m_maxMemAllocSize(); public native b3OpenCLDeviceInfo m_maxMemAllocSize(long setter); - public native int m_queueProperties(); public native b3OpenCLDeviceInfo m_queueProperties(int setter); + public native @Cast("cl_command_queue_properties") long m_queueProperties(); public native b3OpenCLDeviceInfo m_queueProperties(long setter); public native @Cast("bool") boolean m_imageSupport(); public native b3OpenCLDeviceInfo m_imageSupport(boolean setter); public native @Cast("unsigned int") int m_vecWidthChar(); public native b3OpenCLDeviceInfo m_vecWidthChar(int setter); public native @Cast("unsigned int") int m_vecWidthShort(); public native b3OpenCLDeviceInfo m_vecWidthShort(int setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java index a90a9286424..56f6f45f892 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java index a20d2450254..c81cd1142f8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -38,12 +39,12 @@ public class b3OpenCLUtils extends Pointer { /** CL Context optionally takes a GL context. This is a generic type because we don't really want this code * to have to understand GL types. It is a HGLRC in _WIN32 or a GLXContext otherwise. */ - public static native @ByVal cl_context createContextFromType(int deviceType, IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); - public static native @ByVal cl_context createContextFromType(int deviceType, IntPointer pErrNum); - public static native @ByVal cl_context createContextFromType(int deviceType, IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); - public static native @ByVal cl_context createContextFromType(int deviceType, IntBuffer pErrNum); - public static native @ByVal cl_context createContextFromType(int deviceType, int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); - public static native @ByVal cl_context createContextFromType(int deviceType, int[] pErrNum); + public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); + public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, IntPointer pErrNum); + public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); + public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, IntBuffer pErrNum); + public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); + public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, int[] pErrNum); public static native int getNumDevices(@ByVal cl_context cxMainContext); public static native @ByVal cl_device_id getDevice(@ByVal cl_context cxMainContext, int nr); @@ -87,12 +88,12 @@ public class b3OpenCLUtils extends Pointer { public static native void printPlatformInfo(@ByVal cl_platform_id platform); public static native @Cast("const char*") BytePointer getSdkVendorName(); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntPointer pErrNum); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntBuffer pErrNum); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, int[] pErrNum); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntPointer pErrNum); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntBuffer pErrNum); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, int[] pErrNum); public static native void setCachePath(@Cast("const char*") BytePointer path); public static native void setCachePath(String path); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java index 1f9d690cbfd..6f2a46985a3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java index 42e28493b36..8df72aeaf4e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java index e5513a844b9..1e3a5f94df3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java index 17535adbb34..7ce25be2f04 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java index a691d9569d8..555a8443bb1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java index a87f7902e5b..67cefb905fd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java index 2c1096b4019..b8ccab65702 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java index 7ec03af612c..7363df95e23 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java index 4c4a9bfb7d7..08eee5adc35 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java index 88252fc686a..7e4ec2d1155 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java index 7bb1187a251..82ca083c3f1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java index 254bca99533..b0a9065287b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java index bff14e80813..906e1bbf0f4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java index bcd8089a7ce..84d18295cce 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java index db17380d4fc..60dd286539c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java index 730f1dfa9a9..cf9de9a69e8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java index 6ad6332d99e..e75c5a99b01 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java index 6f734a6de5a..b2813dc44f8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java index a9fae43149a..aa57befed60 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java index 8bc7b76f734..808e8485163 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java index a2fce1064b3..6325888b46f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java index 14dc32dccc7..9c447a210d3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java index 7ac78f7e561..9fd4d77b2e3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java index e3f9e779305..b321fc852eb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java index 48d1181289d..8e6c187123a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java index 46d4a9e6c02..02f275e7e05 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java index ccff62a567c..8f5b4c4ec18 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java index 1f576b7fe2c..41cfdf5a882 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java index 86970b32584..5c72af29d4d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java index 1ebf3a288fa..cb0fa7b790f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java index e2163f1d81d..fbf76f617d8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java index 4bf92dc2716..dd6673f1fef 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java index d4c2958aa00..37639b1c783 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java index c5e2b7b7b40..01d0ef745bd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java index 4ab245c1822..efde65db0f9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java index aed62aa8250..cab88f64f4d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java index cee74872fb3..583f7c4000d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java index f56b0611cea..8810312f619 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java index 95f8cdb5356..37dbcda2bf8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java @@ -13,6 +13,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/clew.java b/bullet/src/gen/java/org/bytedeco/bullet/clew.java new file mode 100644 index 00000000000..15d39c8c2d2 --- /dev/null +++ b/bullet/src/gen/java/org/bytedeco/bullet/clew.java @@ -0,0 +1,2015 @@ +// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE + +package org.bytedeco.bullet; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.presets.javacpp.*; + +public class clew extends org.bytedeco.bullet.presets.clew { + static { Loader.load(); } + +// Parsed from clew/clew.h + +// #ifndef CLEW_HPP_INCLUDED + +//! +// #define CLEW_HPP_INCLUDED + +////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2009-2011 Organic Vectory B.V., KindDragon +// Written by George van Venrooij +// +// Distributed under the MIT License. +////////////////////////////////////////////////////////////////////////// + +/** \file clew.h + * \brief OpenCL run-time loader header + * + * This file contains a copy of the contents of CL.H and CL_PLATFORM.H from the + * official OpenCL spec. The purpose of this code is to load the OpenCL dynamic + * library at run-time and thus allow the executable to function on many + * platforms regardless of the vendor of the OpenCL driver actually installed. + * Some of the techniques used here were inspired by work done in the GLEW + * library (http://glew.sourceforge.net/) */ + +// Run-time dynamic linking functionality based on concepts used in GLEW +// #ifdef __OPENCL_CL_H +// #error cl.h included before clew.h +// #endif + +// #ifdef __OPENCL_CL_PLATFORM_H +// #error cl_platform.h included before clew.h +// #endif + +// Prevent cl.h inclusion +// #define __OPENCL_CL_H +// Prevent cl_platform.h inclusion +// #define __CL_PLATFORM_H + +/******************************************************************************* +* Copyright (c) 2008-2010 The Khronos Group Inc. +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and/or associated documentation files (the +* "Materials"), to deal in the Materials without restriction, including +* without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Materials, and to +* permit persons to whom the Materials are furnished to do so, subject to +* the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Materials. +* +* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +******************************************************************************/ +// #ifdef __APPLE__ +/* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */ +// #include +// #endif + +// #ifdef __cplusplus +// #endif + +// #if defined(_WIN32) +// #else +// #define CL_API_ENTRY +// #define CL_API_CALL +// #define CL_CALLBACK +// #endif + //disabled the APPLE thing, don't know why it is there, is just causes tons of warnings + +// #ifdef __APPLE1__ +// #else +// #define CL_EXTENSION_WEAK_LINK +// #define CL_API_SUFFIX__VERSION_1_0 +// #define CL_EXT_SUFFIX__VERSION_1_0 +// #define CL_API_SUFFIX__VERSION_1_1 +// #define CL_EXT_SUFFIX__VERSION_1_1 +// #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED +// #endif + +// #if (defined(_WIN32) && defined(_MSC_VER)) + +// #else + +// #include + +/* scalar types */ + +/* Macro names and corresponding values defined by OpenCL */ +public static final int CL_CHAR_BIT = 8; +public static final int CL_SCHAR_MAX = 127; +public static final int CL_SCHAR_MIN = (-127 - 1); +public static final int CL_CHAR_MAX = CL_SCHAR_MAX; +public static final int CL_CHAR_MIN = CL_SCHAR_MIN; +public static final int CL_UCHAR_MAX = 255; +public static final int CL_SHRT_MAX = 32767; +public static final int CL_SHRT_MIN = (-32767 - 1); +public static final int CL_USHRT_MAX = 65535; +public static final int CL_INT_MAX = 2147483647; +public static final int CL_INT_MIN = (-2147483647 - 1); +public static final int CL_UINT_MAX = 0xffffffff; +public static native @MemberGetter long CL_LONG_MAX(); +public static final long CL_LONG_MAX = CL_LONG_MAX(); +public static native @MemberGetter long CL_LONG_MIN(); +public static final long CL_LONG_MIN = CL_LONG_MIN(); +public static native @MemberGetter @Cast("unsigned long") long CL_ULONG_MAX(); +public static final long CL_ULONG_MAX = CL_ULONG_MAX(); + +public static final int CL_FLT_DIG = 6; +public static final int CL_FLT_MANT_DIG = 24; +public static final int CL_FLT_MAX_10_EXP = +38; +public static final int CL_FLT_MAX_EXP = +128; +public static final int CL_FLT_MIN_10_EXP = -37; +public static final int CL_FLT_MIN_EXP = -125; +public static final int CL_FLT_RADIX = 2; +public static final double CL_FLT_MAX = 0x1.fffffep127f; +public static final double CL_FLT_MIN = 0x1.0p-126f; +public static final double CL_FLT_EPSILON = 0x1.0p-23f; + +public static final int CL_DBL_DIG = 15; +public static final int CL_DBL_MANT_DIG = 53; +public static final int CL_DBL_MAX_10_EXP = +308; +public static final int CL_DBL_MAX_EXP = +1024; +public static final int CL_DBL_MIN_10_EXP = -307; +public static final int CL_DBL_MIN_EXP = -1021; +public static final int CL_DBL_RADIX = 2; +public static final double CL_DBL_MAX = 0x1.fffffffffffffp1023; +public static final double CL_DBL_MIN = 0x1.0p-1022; +public static final double CL_DBL_EPSILON = 0x1.0p-52; + +public static final double CL_M_E = 2.718281828459045090796; +public static final double CL_M_LOG2E = 1.442695040888963387005; +public static final double CL_M_LOG10E = 0.434294481903251816668; +public static final double CL_M_LN2 = 0.693147180559945286227; +public static final double CL_M_LN10 = 2.302585092994045901094; +public static final double CL_M_PI = 3.141592653589793115998; +public static final double CL_M_PI_2 = 1.570796326794896557999; +public static final double CL_M_PI_4 = 0.785398163397448278999; +public static final double CL_M_1_PI = 0.318309886183790691216; +public static final double CL_M_2_PI = 0.636619772367581382433; +public static final double CL_M_2_SQRTPI = 1.128379167095512558561; +public static final double CL_M_SQRT2 = 1.414213562373095145475; +public static final double CL_M_SQRT1_2 = 0.707106781186547572737; + +public static final double CL_M_E_F = 2.71828174591064f; +public static final double CL_M_LOG2E_F = 1.44269502162933f; +public static final double CL_M_LOG10E_F = 0.43429449200630f; +public static final double CL_M_LN2_F = 0.69314718246460f; +public static final double CL_M_LN10_F = 2.30258512496948f; +public static final double CL_M_PI_F = 3.14159274101257f; +public static final double CL_M_PI_2_F = 1.57079637050629f; +public static final double CL_M_PI_4_F = 0.78539818525314f; +public static final double CL_M_1_PI_F = 0.31830987334251f; +public static final double CL_M_2_PI_F = 0.63661974668503f; +public static final double CL_M_2_SQRTPI_F = 1.12837922573090f; +public static final double CL_M_SQRT2_F = 1.41421353816986f; +public static final double CL_M_SQRT1_2_F = 0.70710676908493f; + +// #if defined(__GNUC__) +// #else +public static final double CL_HUGE_VALF = ((float)1e50); +// #define CL_HUGE_VAL ((cl_double)1e500) + +// #define CL_NAN nanf("") +// #endif +public static final double CL_MAXFLOAT = CL_FLT_MAX; +public static final double CL_INFINITY = CL_HUGE_VALF; + +// #endif + +// #include + + /* Mirror types to GL types. Mirror types allow us to avoid deciding which headers to load based on whether we are using GL or GLES here. */ + + /* + * Vector types + * + * Note: OpenCL requires that all types be naturally aligned. + * This means that vector types must be naturally aligned. + * For example, a vector of four floats must be aligned to + * a 16 byte boundary (calculated as 4 * the natural 4-byte + * alignment of the float). The alignment qualifiers here + * will only function properly if your compiler supports them + * and if you don't actively work to defeat them. For example, + * in order for a cl_float4 to be 16 byte aligned in a struct, + * the start of the struct must itself be 16-byte aligned. + * + * Maintaining proper alignment is the user's responsibility. + */ + +// #ifdef _MSC_VER +// #if defined(_M_IX86) +// #if _M_IX86_FP >= 0 +// #define __SSE__ +// #endif +// #if _M_IX86_FP >= 1 +// #define __SSE2__ +// #endif +// #elif defined(_M_X64) +// #define __SSE__ +// #define __SSE2__ +// #endif +// #endif + +/* Define basic vector types */ +// #if defined(__VEC__) +// #endif + +// #if defined(__SSE__) +// #endif + +// #if defined(__SSE2__) +// #endif + +// #if defined(__MMX__) +// #endif + +// #if defined(__AVX__) +// #endif + +/* Define alignment keys */ +// #if defined(__GNUC__) +// #elif defined(_WIN32) && (_MSC_VER) +/* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements */ +/* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx */ +/* #include */ +/* #define CL_ALIGNED(_x) _CRT_ALIGN(_x) */ +// #define CL_ALIGNED(_x) +// #else +// #warning Need to implement some method to align data here +// #define CL_ALIGNED(_x) +// #endif + +/* Indicate whether .xyzw, .s0123 and .hi.lo are supported */ +// #if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) || (defined(_MSC_VER) && !defined(__STDC__)) +/* .xyzw and .s0123...{f|F} are supported */ +public static final int CL_HAS_NAMED_VECTOR_FIELDS = 1; +/* .hi and .lo are supported */ +public static final int CL_HAS_HI_LO_VECTOR_FIELDS = 1; + +// #define CL_NAMED_STRUCT_SUPPORTED +// #endif + +// #if defined(CL_NAMED_STRUCT_SUPPORTED) && defined(_MSC_VER) +// #endif + + /* Define cl_vector types */ + + /* ---- cl_charn ---- */ + public static class cl_char2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_char2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_char2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_char2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_char2 position(long position) { + return (cl_char2)super.position(position); + } + @Override public cl_char2 getPointer(long i) { + return new cl_char2((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_char") byte s(int i); public native cl_char2 s(int i, byte setter); + @MemberGetter public native @Cast("cl_char*") BytePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_CHAR2__) +// #endif + } + + public static class cl_char4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_char4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_char4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_char4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_char4 position(long position) { + return (cl_char4)super.position(position); + } + @Override public cl_char4 getPointer(long i) { + return new cl_char4((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_char") byte s(int i); public native cl_char4 s(int i, byte setter); + @MemberGetter public native @Cast("cl_char*") BytePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_CHAR2__) +// #endif +// #if defined(__CL_CHAR4__) +// #endif + } + + /* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */ + + public static class cl_char8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_char8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_char8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_char8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_char8 position(long position) { + return (cl_char8)super.position(position); + } + @Override public cl_char8 getPointer(long i) { + return new cl_char8((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_char") byte s(int i); public native cl_char8 s(int i, byte setter); + @MemberGetter public native @Cast("cl_char*") BytePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_CHAR2__) +// #endif +// #if defined(__CL_CHAR4__) +// #endif +// #if defined(__CL_CHAR8__) +// #endif + } + + public static class cl_char16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_char16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_char16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_char16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_char16 position(long position) { + return (cl_char16)super.position(position); + } + @Override public cl_char16 getPointer(long i) { + return new cl_char16((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_char") byte s(int i); public native cl_char16 s(int i, byte setter); + @MemberGetter public native @Cast("cl_char*") BytePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_CHAR2__) +// #endif +// #if defined(__CL_CHAR4__) +// #endif +// #if defined(__CL_CHAR8__) +// #endif +// #if defined(__CL_CHAR16__) +// #endif + } + + /* ---- cl_ucharn ---- */ + public static class cl_uchar2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_uchar2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_uchar2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_uchar2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_uchar2 position(long position) { + return (cl_uchar2)super.position(position); + } + @Override public cl_uchar2 getPointer(long i) { + return new cl_uchar2((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_uchar") byte s(int i); public native cl_uchar2 s(int i, byte setter); + @MemberGetter public native @Cast("cl_uchar*") BytePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__cl_uchar2__) +// #endif + } + + public static class cl_uchar4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_uchar4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_uchar4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_uchar4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_uchar4 position(long position) { + return (cl_uchar4)super.position(position); + } + @Override public cl_uchar4 getPointer(long i) { + return new cl_uchar4((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_uchar") byte s(int i); public native cl_uchar4 s(int i, byte setter); + @MemberGetter public native @Cast("cl_uchar*") BytePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_UCHAR2__) +// #endif +// #if defined(__CL_UCHAR4__) +// #endif + } + + /* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */ + + public static class cl_uchar8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_uchar8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_uchar8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_uchar8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_uchar8 position(long position) { + return (cl_uchar8)super.position(position); + } + @Override public cl_uchar8 getPointer(long i) { + return new cl_uchar8((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_uchar") byte s(int i); public native cl_uchar8 s(int i, byte setter); + @MemberGetter public native @Cast("cl_uchar*") BytePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_UCHAR2__) +// #endif +// #if defined(__CL_UCHAR4__) +// #endif +// #if defined(__CL_UCHAR8__) +// #endif + } + + public static class cl_uchar16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_uchar16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_uchar16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_uchar16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_uchar16 position(long position) { + return (cl_uchar16)super.position(position); + } + @Override public cl_uchar16 getPointer(long i) { + return new cl_uchar16((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_uchar") byte s(int i); public native cl_uchar16 s(int i, byte setter); + @MemberGetter public native @Cast("cl_uchar*") BytePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_UCHAR2__) +// #endif +// #if defined(__CL_UCHAR4__) +// #endif +// #if defined(__CL_UCHAR8__) +// #endif +// #if defined(__CL_UCHAR16__) +// #endif + } + + /* ---- cl_shortn ---- */ + public static class cl_short2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_short2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_short2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_short2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_short2 position(long position) { + return (cl_short2)super.position(position); + } + @Override public cl_short2 getPointer(long i) { + return new cl_short2((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_short") short s(int i); public native cl_short2 s(int i, short setter); + @MemberGetter public native @Cast("cl_short*") ShortPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_SHORT2__) +// #endif + } + + public static class cl_short4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_short4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_short4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_short4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_short4 position(long position) { + return (cl_short4)super.position(position); + } + @Override public cl_short4 getPointer(long i) { + return new cl_short4((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_short") short s(int i); public native cl_short4 s(int i, short setter); + @MemberGetter public native @Cast("cl_short*") ShortPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_SHORT2__) +// #endif +// #if defined(__CL_SHORT4__) +// #endif + } + + /* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */ + + public static class cl_short8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_short8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_short8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_short8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_short8 position(long position) { + return (cl_short8)super.position(position); + } + @Override public cl_short8 getPointer(long i) { + return new cl_short8((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_short") short s(int i); public native cl_short8 s(int i, short setter); + @MemberGetter public native @Cast("cl_short*") ShortPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_SHORT2__) +// #endif +// #if defined(__CL_SHORT4__) +// #endif +// #if defined(__CL_SHORT8__) +// #endif + } + + public static class cl_short16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_short16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_short16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_short16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_short16 position(long position) { + return (cl_short16)super.position(position); + } + @Override public cl_short16 getPointer(long i) { + return new cl_short16((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_short") short s(int i); public native cl_short16 s(int i, short setter); + @MemberGetter public native @Cast("cl_short*") ShortPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_SHORT2__) +// #endif +// #if defined(__CL_SHORT4__) +// #endif +// #if defined(__CL_SHORT8__) +// #endif +// #if defined(__CL_SHORT16__) +// #endif + } + + /* ---- cl_ushortn ---- */ + public static class cl_ushort2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_ushort2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_ushort2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_ushort2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_ushort2 position(long position) { + return (cl_ushort2)super.position(position); + } + @Override public cl_ushort2 getPointer(long i) { + return new cl_ushort2((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_ushort") short s(int i); public native cl_ushort2 s(int i, short setter); + @MemberGetter public native @Cast("cl_ushort*") ShortPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_USHORT2__) +// #endif + } + + public static class cl_ushort4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_ushort4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_ushort4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_ushort4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_ushort4 position(long position) { + return (cl_ushort4)super.position(position); + } + @Override public cl_ushort4 getPointer(long i) { + return new cl_ushort4((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_ushort") short s(int i); public native cl_ushort4 s(int i, short setter); + @MemberGetter public native @Cast("cl_ushort*") ShortPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_USHORT2__) +// #endif +// #if defined(__CL_USHORT4__) +// #endif + } + + /* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */ + + public static class cl_ushort8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_ushort8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_ushort8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_ushort8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_ushort8 position(long position) { + return (cl_ushort8)super.position(position); + } + @Override public cl_ushort8 getPointer(long i) { + return new cl_ushort8((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_ushort") short s(int i); public native cl_ushort8 s(int i, short setter); + @MemberGetter public native @Cast("cl_ushort*") ShortPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_USHORT2__) +// #endif +// #if defined(__CL_USHORT4__) +// #endif +// #if defined(__CL_USHORT8__) +// #endif + } + + public static class cl_ushort16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_ushort16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_ushort16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_ushort16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_ushort16 position(long position) { + return (cl_ushort16)super.position(position); + } + @Override public cl_ushort16 getPointer(long i) { + return new cl_ushort16((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_ushort") short s(int i); public native cl_ushort16 s(int i, short setter); + @MemberGetter public native @Cast("cl_ushort*") ShortPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_USHORT2__) +// #endif +// #if defined(__CL_USHORT4__) +// #endif +// #if defined(__CL_USHORT8__) +// #endif +// #if defined(__CL_USHORT16__) +// #endif + } + + /* ---- cl_intn ---- */ + public static class cl_int2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_int2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_int2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_int2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_int2 position(long position) { + return (cl_int2)super.position(position); + } + @Override public cl_int2 getPointer(long i) { + return new cl_int2((Pointer)this).offsetAddress(i); + } + + public native int s(int i); public native cl_int2 s(int i, int setter); + @MemberGetter public native IntPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_INT2__) +// #endif + } + + public static class cl_int4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_int4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_int4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_int4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_int4 position(long position) { + return (cl_int4)super.position(position); + } + @Override public cl_int4 getPointer(long i) { + return new cl_int4((Pointer)this).offsetAddress(i); + } + + public native int s(int i); public native cl_int4 s(int i, int setter); + @MemberGetter public native IntPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_INT2__) +// #endif +// #if defined(__CL_INT4__) +// #endif + } + + /* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */ + + public static class cl_int8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_int8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_int8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_int8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_int8 position(long position) { + return (cl_int8)super.position(position); + } + @Override public cl_int8 getPointer(long i) { + return new cl_int8((Pointer)this).offsetAddress(i); + } + + public native int s(int i); public native cl_int8 s(int i, int setter); + @MemberGetter public native IntPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_INT2__) +// #endif +// #if defined(__CL_INT4__) +// #endif +// #if defined(__CL_INT8__) +// #endif + } + + public static class cl_int16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_int16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_int16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_int16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_int16 position(long position) { + return (cl_int16)super.position(position); + } + @Override public cl_int16 getPointer(long i) { + return new cl_int16((Pointer)this).offsetAddress(i); + } + + public native int s(int i); public native cl_int16 s(int i, int setter); + @MemberGetter public native IntPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_INT2__) +// #endif +// #if defined(__CL_INT4__) +// #endif +// #if defined(__CL_INT8__) +// #endif +// #if defined(__CL_INT16__) +// #endif + } + + /* ---- cl_uintn ---- */ + public static class cl_uint2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_uint2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_uint2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_uint2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_uint2 position(long position) { + return (cl_uint2)super.position(position); + } + @Override public cl_uint2 getPointer(long i) { + return new cl_uint2((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int s(int i); public native cl_uint2 s(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_UINT2__) +// #endif + } + + public static class cl_uint4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_uint4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_uint4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_uint4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_uint4 position(long position) { + return (cl_uint4)super.position(position); + } + @Override public cl_uint4 getPointer(long i) { + return new cl_uint4((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int s(int i); public native cl_uint4 s(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_UINT2__) +// #endif +// #if defined(__CL_UINT4__) +// #endif + } + + /* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */ + + public static class cl_uint8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_uint8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_uint8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_uint8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_uint8 position(long position) { + return (cl_uint8)super.position(position); + } + @Override public cl_uint8 getPointer(long i) { + return new cl_uint8((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int s(int i); public native cl_uint8 s(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_UINT2__) +// #endif +// #if defined(__CL_UINT4__) +// #endif +// #if defined(__CL_UINT8__) +// #endif + } + + public static class cl_uint16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_uint16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_uint16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_uint16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_uint16 position(long position) { + return (cl_uint16)super.position(position); + } + @Override public cl_uint16 getPointer(long i) { + return new cl_uint16((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned int") int s(int i); public native cl_uint16 s(int i, int setter); + @MemberGetter public native @Cast("unsigned int*") IntPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_UINT2__) +// #endif +// #if defined(__CL_UINT4__) +// #endif +// #if defined(__CL_UINT8__) +// #endif +// #if defined(__CL_UINT16__) +// #endif + } + + /* ---- cl_longn ---- */ + + /* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */ + + /* ---- cl_ulongn ---- */ + public static class cl_ulong2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_ulong2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_ulong2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_ulong2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_ulong2 position(long position) { + return (cl_ulong2)super.position(position); + } + @Override public cl_ulong2 getPointer(long i) { + return new cl_ulong2((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned long") long s(int i); public native cl_ulong2 s(int i, long setter); + @MemberGetter public native @Cast("unsigned long*") CLongPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_ULONG2__) +// #endif + } + + public static class cl_ulong4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_ulong4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_ulong4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_ulong4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_ulong4 position(long position) { + return (cl_ulong4)super.position(position); + } + @Override public cl_ulong4 getPointer(long i) { + return new cl_ulong4((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned long") long s(int i); public native cl_ulong4 s(int i, long setter); + @MemberGetter public native @Cast("unsigned long*") CLongPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_ULONG2__) +// #endif +// #if defined(__CL_ULONG4__) +// #endif + } + + /* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */ + + public static class cl_ulong8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_ulong8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_ulong8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_ulong8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_ulong8 position(long position) { + return (cl_ulong8)super.position(position); + } + @Override public cl_ulong8 getPointer(long i) { + return new cl_ulong8((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned long") long s(int i); public native cl_ulong8 s(int i, long setter); + @MemberGetter public native @Cast("unsigned long*") CLongPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_ULONG2__) +// #endif +// #if defined(__CL_ULONG4__) +// #endif +// #if defined(__CL_ULONG8__) +// #endif + } + + public static class cl_ulong16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_ulong16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_ulong16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_ulong16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_ulong16 position(long position) { + return (cl_ulong16)super.position(position); + } + @Override public cl_ulong16 getPointer(long i) { + return new cl_ulong16((Pointer)this).offsetAddress(i); + } + + public native @Cast("unsigned long") long s(int i); public native cl_ulong16 s(int i, long setter); + @MemberGetter public native @Cast("unsigned long*") CLongPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_ULONG2__) +// #endif +// #if defined(__CL_ULONG4__) +// #endif +// #if defined(__CL_ULONG8__) +// #endif +// #if defined(__CL_ULONG16__) +// #endif + } + + /* --- cl_floatn ---- */ + + public static class cl_float2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_float2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_float2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_float2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_float2 position(long position) { + return (cl_float2)super.position(position); + } + @Override public cl_float2 getPointer(long i) { + return new cl_float2((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_float") float s(int i); public native cl_float2 s(int i, float setter); + @MemberGetter public native @Cast("cl_float*") FloatPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_FLOAT2__) +// #endif + } + + public static class cl_float4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_float4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_float4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_float4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_float4 position(long position) { + return (cl_float4)super.position(position); + } + @Override public cl_float4 getPointer(long i) { + return new cl_float4((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_float") float s(int i); public native cl_float4 s(int i, float setter); + @MemberGetter public native @Cast("cl_float*") FloatPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_FLOAT2__) +// #endif +// #if defined(__CL_FLOAT4__) +// #endif + } + + /* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */ + + public static class cl_float8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_float8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_float8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_float8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_float8 position(long position) { + return (cl_float8)super.position(position); + } + @Override public cl_float8 getPointer(long i) { + return new cl_float8((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_float") float s(int i); public native cl_float8 s(int i, float setter); + @MemberGetter public native @Cast("cl_float*") FloatPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_FLOAT2__) +// #endif +// #if defined(__CL_FLOAT4__) +// #endif +// #if defined(__CL_FLOAT8__) +// #endif + } + + public static class cl_float16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_float16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_float16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_float16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_float16 position(long position) { + return (cl_float16)super.position(position); + } + @Override public cl_float16 getPointer(long i) { + return new cl_float16((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_float") float s(int i); public native cl_float16 s(int i, float setter); + @MemberGetter public native @Cast("cl_float*") FloatPointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_FLOAT2__) +// #endif +// #if defined(__CL_FLOAT4__) +// #endif +// #if defined(__CL_FLOAT8__) +// #endif +// #if defined(__CL_FLOAT16__) +// #endif + } + + /* --- cl_doublen ---- */ + + public static class cl_double2 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_double2() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_double2(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_double2(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_double2 position(long position) { + return (cl_double2)super.position(position); + } + @Override public cl_double2 getPointer(long i) { + return new cl_double2((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_double") double s(int i); public native cl_double2 s(int i, double setter); + @MemberGetter public native @Cast("cl_double*") DoublePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_DOUBLE2__) +// #endif + } + + public static class cl_double4 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_double4() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_double4(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_double4(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_double4 position(long position) { + return (cl_double4)super.position(position); + } + @Override public cl_double4 getPointer(long i) { + return new cl_double4((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_double") double s(int i); public native cl_double4 s(int i, double setter); + @MemberGetter public native @Cast("cl_double*") DoublePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_DOUBLE2__) +// #endif +// #if defined(__CL_DOUBLE4__) +// #endif + } + + /* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */ + + public static class cl_double8 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_double8() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_double8(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_double8(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_double8 position(long position) { + return (cl_double8)super.position(position); + } + @Override public cl_double8 getPointer(long i) { + return new cl_double8((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_double") double s(int i); public native cl_double8 s(int i, double setter); + @MemberGetter public native @Cast("cl_double*") DoublePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_DOUBLE2__) +// #endif +// #if defined(__CL_DOUBLE4__) +// #endif +// #if defined(__CL_DOUBLE8__) +// #endif + } + + public static class cl_double16 extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_double16() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_double16(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_double16(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_double16 position(long position) { + return (cl_double16)super.position(position); + } + @Override public cl_double16 getPointer(long i) { + return new cl_double16((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_double") double s(int i); public native cl_double16 s(int i, double setter); + @MemberGetter public native @Cast("cl_double*") DoublePointer s(); +// #if defined(CL_NAMED_STRUCT_SUPPORTED) +// #endif +// #if defined(__CL_DOUBLE2__) +// #endif +// #if defined(__CL_DOUBLE4__) +// #endif +// #if defined(__CL_DOUBLE8__) +// #endif +// #if defined(__CL_DOUBLE16__) +// #endif + } + +/* Macro to facilitate debugging + * Usage: + * Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source. + * The first line ends with: CL_PROGRAM_STRING_BEGIN \" + * Each line thereafter of OpenCL C source must end with: \n\ + * The last line ends in "; + * + * Example: + * + * const char *my_program = CL_PROGRAM_STRING_BEGIN "\ + * kernel void foo( int a, float * b ) \n\ + * { \n\ + * // my comment \n\ + * *b[ get_global_id(0)] = a; \n\ + * } \n\ + * "; + * + * This should correctly set up the line, (column) and file information for your source + * string so you can do source level debugging. + */ +// #define __CL_STRINGIFY(_x) #_x +// #define _CL_STRINGIFY(_x) __CL_STRINGIFY(_x) +// #define CL_PROGRAM_STRING_DEBUG_INFO "#line " _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n" + + // CL.h contents + /******************************************************************************/ + + @Opaque public static class _cl_platform_id extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_platform_id() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_platform_id(Pointer p) { super(p); } + } + @Opaque public static class _cl_device_id extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_device_id() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_device_id(Pointer p) { super(p); } + } + @Opaque public static class _cl_context extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_context() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_context(Pointer p) { super(p); } + } + @Opaque public static class _cl_command_queue extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_command_queue() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_command_queue(Pointer p) { super(p); } + } + @Opaque public static class _cl_mem extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_mem() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_mem(Pointer p) { super(p); } + } + @Opaque public static class _cl_program extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_program() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_program(Pointer p) { super(p); } + } + @Opaque public static class _cl_kernel extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_kernel() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_kernel(Pointer p) { super(p); } + } + @Opaque public static class _cl_event extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_event() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_event(Pointer p) { super(p); } + } + @Opaque public static class _cl_sampler extends Pointer { + /** Empty constructor. Calls {@code super((Pointer)null)}. */ + public _cl_sampler() { super((Pointer)null); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public _cl_sampler(Pointer p) { super(p); } + } /* WARNING! Unlike cl_ types in cl_platform.h, cl_bool is not guaranteed to be the same size as the bool in kernels. */ + + public static class cl_image_format extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_image_format() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_image_format(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_image_format(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_image_format position(long position) { + return (cl_image_format)super.position(position); + } + @Override public cl_image_format getPointer(long i) { + return new cl_image_format((Pointer)this).offsetAddress(i); + } + + public native @Cast("cl_channel_order") int image_channel_order(); public native cl_image_format image_channel_order(int setter); + public native @Cast("cl_channel_type") int image_channel_data_type(); public native cl_image_format image_channel_data_type(int setter); + } + + public static class cl_buffer_region extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public cl_buffer_region() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public cl_buffer_region(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public cl_buffer_region(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public cl_buffer_region position(long position) { + return (cl_buffer_region)super.position(position); + } + @Override public cl_buffer_region getPointer(long i) { + return new cl_buffer_region((Pointer)this).offsetAddress(i); + } + + public native @Cast("size_t") long origin(); public native cl_buffer_region origin(long setter); + public native @Cast("size_t") long size(); public native cl_buffer_region size(long setter); + } + +/******************************************************************************/ + +/* Error Codes */ +public static final int CL_SUCCESS = 0; +public static final int CL_DEVICE_NOT_FOUND = -1; +public static final int CL_DEVICE_NOT_AVAILABLE = -2; +public static final int CL_COMPILER_NOT_AVAILABLE = -3; +public static final int CL_MEM_OBJECT_ALLOCATION_FAILURE = -4; +public static final int CL_OUT_OF_RESOURCES = -5; +public static final int CL_OUT_OF_HOST_MEMORY = -6; +public static final int CL_PROFILING_INFO_NOT_AVAILABLE = -7; +public static final int CL_MEM_COPY_OVERLAP = -8; +public static final int CL_IMAGE_FORMAT_MISMATCH = -9; +public static final int CL_IMAGE_FORMAT_NOT_SUPPORTED = -10; +public static final int CL_BUILD_PROGRAM_FAILURE = -11; +public static final int CL_MAP_FAILURE = -12; +public static final int CL_MISALIGNED_SUB_BUFFER_OFFSET = -13; +public static final int CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST = -14; + +public static final int CL_INVALID_VALUE = -30; +public static final int CL_INVALID_DEVICE_TYPE = -31; +public static final int CL_INVALID_PLATFORM = -32; +public static final int CL_INVALID_DEVICE = -33; +public static final int CL_INVALID_CONTEXT = -34; +public static final int CL_INVALID_QUEUE_PROPERTIES = -35; +public static final int CL_INVALID_COMMAND_QUEUE = -36; +public static final int CL_INVALID_HOST_PTR = -37; +public static final int CL_INVALID_MEM_OBJECT = -38; +public static final int CL_INVALID_IMAGE_FORMAT_DESCRIPTOR = -39; +public static final int CL_INVALID_IMAGE_SIZE = -40; +public static final int CL_INVALID_SAMPLER = -41; +public static final int CL_INVALID_BINARY = -42; +public static final int CL_INVALID_BUILD_OPTIONS = -43; +public static final int CL_INVALID_PROGRAM = -44; +public static final int CL_INVALID_PROGRAM_EXECUTABLE = -45; +public static final int CL_INVALID_KERNEL_NAME = -46; +public static final int CL_INVALID_KERNEL_DEFINITION = -47; +public static final int CL_INVALID_KERNEL = -48; +public static final int CL_INVALID_ARG_INDEX = -49; +public static final int CL_INVALID_ARG_VALUE = -50; +public static final int CL_INVALID_ARG_SIZE = -51; +public static final int CL_INVALID_KERNEL_ARGS = -52; +public static final int CL_INVALID_WORK_DIMENSION = -53; +public static final int CL_INVALID_WORK_GROUP_SIZE = -54; +public static final int CL_INVALID_WORK_ITEM_SIZE = -55; +public static final int CL_INVALID_GLOBAL_OFFSET = -56; +public static final int CL_INVALID_EVENT_WAIT_LIST = -57; +public static final int CL_INVALID_EVENT = -58; +public static final int CL_INVALID_OPERATION = -59; +public static final int CL_INVALID_GL_OBJECT = -60; +public static final int CL_INVALID_BUFFER_SIZE = -61; +public static final int CL_INVALID_MIP_LEVEL = -62; +public static final int CL_INVALID_GLOBAL_WORK_SIZE = -63; +public static final int CL_INVALID_PROPERTY = -64; + +/* OpenCL Version */ +public static final int CL_VERSION_1_0 = 1; +public static final int CL_VERSION_1_1 = 1; + +/* cl_bool */ +public static final int CL_FALSE = 0; +public static final int CL_TRUE = 1; + +/* cl_platform_info */ +public static final int CL_PLATFORM_PROFILE = 0x0900; +public static final int CL_PLATFORM_VERSION = 0x0901; +public static final int CL_PLATFORM_NAME = 0x0902; +public static final int CL_PLATFORM_VENDOR = 0x0903; +public static final int CL_PLATFORM_EXTENSIONS = 0x0904; + +/* cl_device_type - bitfield */ +public static final int CL_DEVICE_TYPE_DEFAULT = (1 << 0); +public static final int CL_DEVICE_TYPE_CPU = (1 << 1); +public static final int CL_DEVICE_TYPE_GPU = (1 << 2); +public static final int CL_DEVICE_TYPE_ACCELERATOR = (1 << 3); +public static final int CL_DEVICE_TYPE_ALL = 0xFFFFFFFF; + +/* cl_device_info */ +public static final int CL_DEVICE_TYPE = 0x1000; +public static final int CL_DEVICE_VENDOR_ID = 0x1001; +public static final int CL_DEVICE_MAX_COMPUTE_UNITS = 0x1002; +public static final int CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS = 0x1003; +public static final int CL_DEVICE_MAX_WORK_GROUP_SIZE = 0x1004; +public static final int CL_DEVICE_MAX_WORK_ITEM_SIZES = 0x1005; +public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR = 0x1006; +public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT = 0x1007; +public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT = 0x1008; +public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG = 0x1009; +public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT = 0x100A; +public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE = 0x100B; +public static final int CL_DEVICE_MAX_CLOCK_FREQUENCY = 0x100C; +public static final int CL_DEVICE_ADDRESS_BITS = 0x100D; +public static final int CL_DEVICE_MAX_READ_IMAGE_ARGS = 0x100E; +public static final int CL_DEVICE_MAX_WRITE_IMAGE_ARGS = 0x100F; +public static final int CL_DEVICE_MAX_MEM_ALLOC_SIZE = 0x1010; +public static final int CL_DEVICE_IMAGE2D_MAX_WIDTH = 0x1011; +public static final int CL_DEVICE_IMAGE2D_MAX_HEIGHT = 0x1012; +public static final int CL_DEVICE_IMAGE3D_MAX_WIDTH = 0x1013; +public static final int CL_DEVICE_IMAGE3D_MAX_HEIGHT = 0x1014; +public static final int CL_DEVICE_IMAGE3D_MAX_DEPTH = 0x1015; +public static final int CL_DEVICE_IMAGE_SUPPORT = 0x1016; +public static final int CL_DEVICE_MAX_PARAMETER_SIZE = 0x1017; +public static final int CL_DEVICE_MAX_SAMPLERS = 0x1018; +public static final int CL_DEVICE_MEM_BASE_ADDR_ALIGN = 0x1019; +public static final int CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE = 0x101A; +public static final int CL_DEVICE_SINGLE_FP_CONFIG = 0x101B; +public static final int CL_DEVICE_GLOBAL_MEM_CACHE_TYPE = 0x101C; +public static final int CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE = 0x101D; +public static final int CL_DEVICE_GLOBAL_MEM_CACHE_SIZE = 0x101E; +public static final int CL_DEVICE_GLOBAL_MEM_SIZE = 0x101F; +public static final int CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE = 0x1020; +public static final int CL_DEVICE_MAX_CONSTANT_ARGS = 0x1021; +public static final int CL_DEVICE_LOCAL_MEM_TYPE = 0x1022; +public static final int CL_DEVICE_LOCAL_MEM_SIZE = 0x1023; +public static final int CL_DEVICE_ERROR_CORRECTION_SUPPORT = 0x1024; +public static final int CL_DEVICE_PROFILING_TIMER_RESOLUTION = 0x1025; +public static final int CL_DEVICE_ENDIAN_LITTLE = 0x1026; +public static final int CL_DEVICE_AVAILABLE = 0x1027; +public static final int CL_DEVICE_COMPILER_AVAILABLE = 0x1028; +public static final int CL_DEVICE_EXECUTION_CAPABILITIES = 0x1029; +public static final int CL_DEVICE_QUEUE_PROPERTIES = 0x102A; +public static final int CL_DEVICE_NAME = 0x102B; +public static final int CL_DEVICE_VENDOR = 0x102C; +public static final int CL_DRIVER_VERSION = 0x102D; +public static final int CL_DEVICE_PROFILE = 0x102E; +public static final int CL_DEVICE_VERSION = 0x102F; +public static final int CL_DEVICE_EXTENSIONS = 0x1030; +public static final int CL_DEVICE_PLATFORM = 0x1031; +/* 0x1032 reserved for CL_DEVICE_DOUBLE_FP_CONFIG */ +/* 0x1033 reserved for CL_DEVICE_HALF_FP_CONFIG */ +public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF = 0x1034; +public static final int CL_DEVICE_HOST_UNIFIED_MEMORY = 0x1035; +public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR = 0x1036; +public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT = 0x1037; +public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_INT = 0x1038; +public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG = 0x1039; +public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT = 0x103A; +public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE = 0x103B; +public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF = 0x103C; +public static final int CL_DEVICE_OPENCL_C_VERSION = 0x103D; + +/* cl_device_fp_config - bitfield */ +public static final int CL_FP_DENORM = (1 << 0); +public static final int CL_FP_INF_NAN = (1 << 1); +public static final int CL_FP_ROUND_TO_NEAREST = (1 << 2); +public static final int CL_FP_ROUND_TO_ZERO = (1 << 3); +public static final int CL_FP_ROUND_TO_INF = (1 << 4); +public static final int CL_FP_FMA = (1 << 5); +public static final int CL_FP_SOFT_FLOAT = (1 << 6); + +/* cl_device_mem_cache_type */ +public static final int CL_NONE = 0x0; +public static final int CL_READ_ONLY_CACHE = 0x1; +public static final int CL_READ_WRITE_CACHE = 0x2; + +/* cl_device_local_mem_type */ +public static final int CL_LOCAL = 0x1; +public static final int CL_GLOBAL = 0x2; + +/* cl_device_exec_capabilities - bitfield */ +public static final int CL_EXEC_KERNEL = (1 << 0); +public static final int CL_EXEC_NATIVE_KERNEL = (1 << 1); + +/* cl_command_queue_properties - bitfield */ +public static final int CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE = (1 << 0); +public static final int CL_QUEUE_PROFILING_ENABLE = (1 << 1); + +/* cl_context_info */ +public static final int CL_CONTEXT_REFERENCE_COUNT = 0x1080; +public static final int CL_CONTEXT_DEVICES = 0x1081; +public static final int CL_CONTEXT_PROPERTIES = 0x1082; +public static final int CL_CONTEXT_NUM_DEVICES = 0x1083; + +/* cl_context_info + cl_context_properties */ +public static final int CL_CONTEXT_PLATFORM = 0x1084; + +/* cl_command_queue_info */ +public static final int CL_QUEUE_CONTEXT = 0x1090; +public static final int CL_QUEUE_DEVICE = 0x1091; +public static final int CL_QUEUE_REFERENCE_COUNT = 0x1092; +public static final int CL_QUEUE_PROPERTIES = 0x1093; + +/* cl_mem_flags - bitfield */ +public static final int CL_MEM_READ_WRITE = (1 << 0); +public static final int CL_MEM_WRITE_ONLY = (1 << 1); +public static final int CL_MEM_READ_ONLY = (1 << 2); +public static final int CL_MEM_USE_HOST_PTR = (1 << 3); +public static final int CL_MEM_ALLOC_HOST_PTR = (1 << 4); +public static final int CL_MEM_COPY_HOST_PTR = (1 << 5); + +/* cl_channel_order */ +public static final int CL_R = 0x10B0; +public static final int CL_A = 0x10B1; +public static final int CL_RG = 0x10B2; +public static final int CL_RA = 0x10B3; +public static final int CL_RGB = 0x10B4; +public static final int CL_RGBA = 0x10B5; +public static final int CL_BGRA = 0x10B6; +public static final int CL_ARGB = 0x10B7; +public static final int CL_INTENSITY = 0x10B8; +public static final int CL_LUMINANCE = 0x10B9; +public static final int CL_Rx = 0x10BA; +public static final int CL_RGx = 0x10BB; +public static final int CL_RGBx = 0x10BC; + +/* cl_channel_type */ +public static final int CL_SNORM_INT8 = 0x10D0; +public static final int CL_SNORM_INT16 = 0x10D1; +public static final int CL_UNORM_INT8 = 0x10D2; +public static final int CL_UNORM_INT16 = 0x10D3; +public static final int CL_UNORM_SHORT_565 = 0x10D4; +public static final int CL_UNORM_SHORT_555 = 0x10D5; +public static final int CL_UNORM_INT_101010 = 0x10D6; +public static final int CL_SIGNED_INT8 = 0x10D7; +public static final int CL_SIGNED_INT16 = 0x10D8; +public static final int CL_SIGNED_INT32 = 0x10D9; +public static final int CL_UNSIGNED_INT8 = 0x10DA; +public static final int CL_UNSIGNED_INT16 = 0x10DB; +public static final int CL_UNSIGNED_INT32 = 0x10DC; +public static final int CL_HALF_FLOAT = 0x10DD; +public static final int CL_FLOAT = 0x10DE; + +/* cl_mem_object_type */ +public static final int CL_MEM_OBJECT_BUFFER = 0x10F0; +public static final int CL_MEM_OBJECT_IMAGE2D = 0x10F1; +public static final int CL_MEM_OBJECT_IMAGE3D = 0x10F2; + +/* cl_mem_info */ +public static final int CL_MEM_TYPE = 0x1100; +public static final int CL_MEM_FLAGS = 0x1101; +public static final int CL_MEM_SIZE = 0x1102; +public static final int CL_MEM_HOST_PTR = 0x1103; +public static final int CL_MEM_MAP_COUNT = 0x1104; +public static final int CL_MEM_REFERENCE_COUNT = 0x1105; +public static final int CL_MEM_CONTEXT = 0x1106; +public static final int CL_MEM_ASSOCIATED_MEMOBJECT = 0x1107; +public static final int CL_MEM_OFFSET = 0x1108; + +/* cl_image_info */ +public static final int CL_IMAGE_FORMAT = 0x1110; +public static final int CL_IMAGE_ELEMENT_SIZE = 0x1111; +public static final int CL_IMAGE_ROW_PITCH = 0x1112; +public static final int CL_IMAGE_SLICE_PITCH = 0x1113; +public static final int CL_IMAGE_WIDTH = 0x1114; +public static final int CL_IMAGE_HEIGHT = 0x1115; +public static final int CL_IMAGE_DEPTH = 0x1116; + +/* cl_addressing_mode */ +public static final int CL_ADDRESS_NONE = 0x1130; +public static final int CL_ADDRESS_CLAMP_TO_EDGE = 0x1131; +public static final int CL_ADDRESS_CLAMP = 0x1132; +public static final int CL_ADDRESS_REPEAT = 0x1133; +public static final int CL_ADDRESS_MIRRORED_REPEAT = 0x1134; + +/* cl_filter_mode */ +public static final int CL_FILTER_NEAREST = 0x1140; +public static final int CL_FILTER_LINEAR = 0x1141; + +/* cl_sampler_info */ +public static final int CL_SAMPLER_REFERENCE_COUNT = 0x1150; +public static final int CL_SAMPLER_CONTEXT = 0x1151; +public static final int CL_SAMPLER_NORMALIZED_COORDS = 0x1152; +public static final int CL_SAMPLER_ADDRESSING_MODE = 0x1153; +public static final int CL_SAMPLER_FILTER_MODE = 0x1154; + +/* cl_map_flags - bitfield */ +public static final int CL_MAP_READ = (1 << 0); +public static final int CL_MAP_WRITE = (1 << 1); + +/* cl_program_info */ +public static final int CL_PROGRAM_REFERENCE_COUNT = 0x1160; +public static final int CL_PROGRAM_CONTEXT = 0x1161; +public static final int CL_PROGRAM_NUM_DEVICES = 0x1162; +public static final int CL_PROGRAM_DEVICES = 0x1163; +public static final int CL_PROGRAM_SOURCE = 0x1164; +public static final int CL_PROGRAM_BINARY_SIZES = 0x1165; +public static final int CL_PROGRAM_BINARIES = 0x1166; + +/* cl_program_build_info */ +public static final int CL_PROGRAM_BUILD_STATUS = 0x1181; +public static final int CL_PROGRAM_BUILD_OPTIONS = 0x1182; +public static final int CL_PROGRAM_BUILD_LOG = 0x1183; + +/* cl_build_status */ +public static final int CL_BUILD_SUCCESS = 0; +public static final int CL_BUILD_NONE = -1; +public static final int CL_BUILD_ERROR = -2; +public static final int CL_BUILD_IN_PROGRESS = -3; + +/* cl_kernel_info */ +public static final int CL_KERNEL_FUNCTION_NAME = 0x1190; +public static final int CL_KERNEL_NUM_ARGS = 0x1191; +public static final int CL_KERNEL_REFERENCE_COUNT = 0x1192; +public static final int CL_KERNEL_CONTEXT = 0x1193; +public static final int CL_KERNEL_PROGRAM = 0x1194; + +/* cl_kernel_work_group_info */ +public static final int CL_KERNEL_WORK_GROUP_SIZE = 0x11B0; +public static final int CL_KERNEL_COMPILE_WORK_GROUP_SIZE = 0x11B1; +public static final int CL_KERNEL_LOCAL_MEM_SIZE = 0x11B2; +public static final int CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE = 0x11B3; +public static final int CL_KERNEL_PRIVATE_MEM_SIZE = 0x11B4; + +/* cl_event_info */ +public static final int CL_EVENT_COMMAND_QUEUE = 0x11D0; +public static final int CL_EVENT_COMMAND_TYPE = 0x11D1; +public static final int CL_EVENT_REFERENCE_COUNT = 0x11D2; +public static final int CL_EVENT_COMMAND_EXECUTION_STATUS = 0x11D3; +public static final int CL_EVENT_CONTEXT = 0x11D4; + +/* cl_command_type */ +public static final int CL_COMMAND_NDRANGE_KERNEL = 0x11F0; +public static final int CL_COMMAND_TASK = 0x11F1; +public static final int CL_COMMAND_NATIVE_KERNEL = 0x11F2; +public static final int CL_COMMAND_READ_BUFFER = 0x11F3; +public static final int CL_COMMAND_WRITE_BUFFER = 0x11F4; +public static final int CL_COMMAND_COPY_BUFFER = 0x11F5; +public static final int CL_COMMAND_READ_IMAGE = 0x11F6; +public static final int CL_COMMAND_WRITE_IMAGE = 0x11F7; +public static final int CL_COMMAND_COPY_IMAGE = 0x11F8; +public static final int CL_COMMAND_COPY_IMAGE_TO_BUFFER = 0x11F9; +public static final int CL_COMMAND_COPY_BUFFER_TO_IMAGE = 0x11FA; +public static final int CL_COMMAND_MAP_BUFFER = 0x11FB; +public static final int CL_COMMAND_MAP_IMAGE = 0x11FC; +public static final int CL_COMMAND_UNMAP_MEM_OBJECT = 0x11FD; +public static final int CL_COMMAND_MARKER = 0x11FE; +public static final int CL_COMMAND_ACQUIRE_GL_OBJECTS = 0x11FF; +public static final int CL_COMMAND_RELEASE_GL_OBJECTS = 0x1200; +public static final int CL_COMMAND_READ_BUFFER_RECT = 0x1201; +public static final int CL_COMMAND_WRITE_BUFFER_RECT = 0x1202; +public static final int CL_COMMAND_COPY_BUFFER_RECT = 0x1203; +public static final int CL_COMMAND_USER = 0x1204; + +/* command execution status */ +public static final int CL_COMPLETE = 0x0; +public static final int CL_RUNNING = 0x1; +public static final int CL_SUBMITTED = 0x2; +public static final int CL_QUEUED = 0x3; + +/* cl_buffer_create_type */ +public static final int CL_BUFFER_CREATE_TYPE_REGION = 0x1220; + +/* cl_profiling_info */ +public static final int CL_PROFILING_COMMAND_QUEUED = 0x1280; +public static final int CL_PROFILING_COMMAND_SUBMIT = 0x1281; +public static final int CL_PROFILING_COMMAND_START = 0x1282; +public static final int CL_PROFILING_COMMAND_END = 0x1283; + + /********************************************************************************************************/ + + /********************************************************************************************************/ + + /* Function signature typedef's */ + + /* Platform API */ + +/** Success error code */ +public static final int CLEW_SUCCESS = 0; +/** Error code for failing to open the dynamic library */ +public static final int CLEW_ERROR_OPEN_FAILED = -1; +/** Error code for failing to queue the closing of the dynamic library to atexit() */ +public static final int CLEW_ERROR_ATEXIT_FAILED = -2; + + /** \brief Load OpenCL dynamic library and set function entry points */ + public static native int clewInit(@Cast("const char*") BytePointer arg0); + public static native int clewInit(String arg0); + + /** \brief Exit clew and unload OpenCL dynamic library */ + public static native void clewExit(); + + /** \brief Convert an OpenCL error code to its string equivalent */ + public static native @Cast("const char*") BytePointer clewErrorString(int error); + +// #ifdef __cplusplus +// #endif + +// #endif // CLEW_HPP_INCLUDED + + +// Parsed from clew_stubs.h + +/* + * Copyright (C) 2022 Andrey Krainyak + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + + +// This #ifdef disables these stubs during native code compilation, +// as the stubs should be used for generation of the Java-side +// code only, and the native code should use the original definitions +// provided by clew's header. +// #ifdef XXXXXXXXXX + +public static class BuildProgramCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public BuildProgramCallback(Pointer p) { super(p); } + protected BuildProgramCallback() { allocate(); } + private native void allocate(); + public native void call(@ByVal cl_program arg0, Pointer arg1); +} +public static native int clBuildProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const char*") BytePointer arg3, BuildProgramCallback arg4, Pointer arg5); +public static native int clBuildProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, String arg3, BuildProgramCallback arg4, Pointer arg5); + +public static class CreateContextCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public CreateContextCallback(Pointer p) { super(p); } + protected CreateContextCallback() { allocate(); } + private native void allocate(); + public native void call(@Cast("const char*") BytePointer arg0, @Const Pointer arg1, @Cast("size_t") long arg2, Pointer arg3); +} +public static native @ByVal cl_context clCreateContext(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, CreateContextCallback arg3, Pointer arg4, IntPointer arg5); +public static native @ByVal cl_context clCreateContext(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, CreateContextCallback arg3, Pointer arg4, IntBuffer arg5); +public static native @ByVal cl_context clCreateContext(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, CreateContextCallback arg3, Pointer arg4, int[] arg5); +public static native @ByVal cl_context clCreateContextFromType(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("cl_device_type") long arg1, CreateContextCallback arg2, Pointer arg3, IntPointer arg4); +public static native @ByVal cl_context clCreateContextFromType(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("cl_device_type") long arg1, CreateContextCallback arg2, Pointer arg3, IntBuffer arg4); +public static native @ByVal cl_context clCreateContextFromType(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("cl_device_type") long arg1, CreateContextCallback arg2, Pointer arg3, int[] arg4); + +public static class EnqueueNativeKernelCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public EnqueueNativeKernelCallback(Pointer p) { super(p); } + protected EnqueueNativeKernelCallback() { allocate(); } + private native void allocate(); + public native void call(Pointer arg0); +} +public static native int clEnqueueNativeKernel(@ByVal cl_command_queue arg0, EnqueueNativeKernelCallback arg1, Pointer arg2, @Cast("size_t") long arg3, @Cast("unsigned int") int arg4, @Const cl_mem arg5, @Cast("const void**") PointerPointer arg6, @Cast("unsigned int") int arg7, @Const cl_event arg8, cl_event arg9); +public static native int clEnqueueNativeKernel(@ByVal cl_command_queue arg0, EnqueueNativeKernelCallback arg1, Pointer arg2, @Cast("size_t") long arg3, @Cast("unsigned int") int arg4, @Const cl_mem arg5, @Cast("const void**") @ByPtrPtr Pointer arg6, @Cast("unsigned int") int arg7, @Const cl_event arg8, cl_event arg9); + +public static class EventCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public EventCallback(Pointer p) { super(p); } + protected EventCallback() { allocate(); } + private native void allocate(); + public native void call(@ByVal cl_event arg0, int arg1, Pointer arg2); +} +public static native int clSetEventCallback(@ByVal cl_event arg0, int arg1, EventCallback arg2, Pointer arg3); + +public static class MemObjectDestructorCallback extends FunctionPointer { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public MemObjectDestructorCallback(Pointer p) { super(p); } + protected MemObjectDestructorCallback() { allocate(); } + private native void allocate(); + public native void call(@ByVal cl_mem arg0, Pointer arg1); +} +public static native int clSetMemObjectDestructorCallback(@ByVal cl_mem arg0, MemObjectDestructorCallback arg1, Pointer arg2); + +/*************************************************************************** + Generated with bullet/gen-clew-stubs script +***************************************************************************/ + +public static native @ByVal cl_mem clCreateBuffer(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("size_t") long arg2, Pointer arg3, IntPointer arg4); +public static native @ByVal cl_mem clCreateBuffer(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("size_t") long arg2, Pointer arg3, IntBuffer arg4); +public static native @ByVal cl_mem clCreateBuffer(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("size_t") long arg2, Pointer arg3, int[] arg4); +public static native @ByVal cl_command_queue clCreateCommandQueue(@ByVal cl_context arg0, @ByVal cl_device_id arg1, @Cast("cl_command_queue_properties") long arg2, IntPointer arg3); +public static native @ByVal cl_command_queue clCreateCommandQueue(@ByVal cl_context arg0, @ByVal cl_device_id arg1, @Cast("cl_command_queue_properties") long arg2, IntBuffer arg3); +public static native @ByVal cl_command_queue clCreateCommandQueue(@ByVal cl_context arg0, @ByVal cl_device_id arg1, @Cast("cl_command_queue_properties") long arg2, int[] arg3); +public static native @ByVal cl_mem clCreateImage2D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, Pointer arg6, IntPointer arg7); +public static native @ByVal cl_mem clCreateImage2D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, Pointer arg6, IntBuffer arg7); +public static native @ByVal cl_mem clCreateImage2D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, Pointer arg6, int[] arg7); +public static native @ByVal cl_mem clCreateImage3D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, Pointer arg8, IntPointer arg9); +public static native @ByVal cl_mem clCreateImage3D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, Pointer arg8, IntBuffer arg9); +public static native @ByVal cl_mem clCreateImage3D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, Pointer arg8, int[] arg9); +public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, @Cast("const char*") BytePointer arg1, IntPointer arg2); +public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, String arg1, IntBuffer arg2); +public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, @Cast("const char*") BytePointer arg1, int[] arg2); +public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, String arg1, IntPointer arg2); +public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, @Cast("const char*") BytePointer arg1, IntBuffer arg2); +public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, String arg1, int[] arg2); +public static native int clCreateKernelsInProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, cl_kernel arg2, @Cast("unsigned int*") IntPointer arg3); +public static native int clCreateKernelsInProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, cl_kernel arg2, @Cast("unsigned int*") IntBuffer arg3); +public static native int clCreateKernelsInProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, cl_kernel arg2, @Cast("unsigned int*") int[] arg3); +public static native @ByVal cl_program clCreateProgramWithBinary(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const unsigned char**") PointerPointer arg4, IntPointer arg5, IntPointer arg6); +public static native @ByVal cl_program clCreateProgramWithBinary(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const unsigned char**") @ByPtrPtr BytePointer arg4, IntPointer arg5, IntPointer arg6); +public static native @ByVal cl_program clCreateProgramWithBinary(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer arg4, IntBuffer arg5, IntBuffer arg6); +public static native @ByVal cl_program clCreateProgramWithBinary(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const unsigned char**") @ByPtrPtr byte[] arg4, int[] arg5, int[] arg6); +public static native @ByVal cl_program clCreateProgramWithSource(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Cast("const char**") PointerPointer arg2, @Cast("const size_t*") SizeTPointer arg3, IntPointer arg4); +public static native @ByVal cl_program clCreateProgramWithSource(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Cast("const char**") @ByPtrPtr BytePointer arg2, @Cast("const size_t*") SizeTPointer arg3, IntPointer arg4); +public static native @ByVal cl_program clCreateProgramWithSource(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Cast("const char**") @ByPtrPtr ByteBuffer arg2, @Cast("const size_t*") SizeTPointer arg3, IntBuffer arg4); +public static native @ByVal cl_program clCreateProgramWithSource(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Cast("const char**") @ByPtrPtr byte[] arg2, @Cast("const size_t*") SizeTPointer arg3, int[] arg4); +public static native @ByVal cl_sampler clCreateSampler(@ByVal cl_context arg0, @Cast("bool") boolean arg1, @Cast("cl_addressing_mode") int arg2, @Cast("cl_filter_mode") int arg3, IntPointer arg4); +public static native @ByVal cl_sampler clCreateSampler(@ByVal cl_context arg0, @Cast("bool") boolean arg1, @Cast("cl_addressing_mode") int arg2, @Cast("cl_filter_mode") int arg3, IntBuffer arg4); +public static native @ByVal cl_sampler clCreateSampler(@ByVal cl_context arg0, @Cast("bool") boolean arg1, @Cast("cl_addressing_mode") int arg2, @Cast("cl_filter_mode") int arg3, int[] arg4); +public static native @ByVal cl_mem clCreateSubBuffer(@ByVal cl_mem arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_buffer_create_type") int arg2, @Const Pointer arg3, IntPointer arg4); +public static native @ByVal cl_mem clCreateSubBuffer(@ByVal cl_mem arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_buffer_create_type") int arg2, @Const Pointer arg3, IntBuffer arg4); +public static native @ByVal cl_mem clCreateSubBuffer(@ByVal cl_mem arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_buffer_create_type") int arg2, @Const Pointer arg3, int[] arg4); +public static native @ByVal cl_event clCreateUserEvent(@ByVal cl_context arg0, IntPointer arg1); +public static native @ByVal cl_event clCreateUserEvent(@ByVal cl_context arg0, IntBuffer arg1); +public static native @ByVal cl_event clCreateUserEvent(@ByVal cl_context arg0, int[] arg1); +public static native int clEnqueueBarrier(@ByVal cl_command_queue arg0); +public static native int clEnqueueCopyBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); +public static native int clEnqueueCopyBufferRect(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, @Cast("size_t") long arg8, @Cast("size_t") long arg9, @Cast("unsigned int") int arg10, @Const cl_event arg11, cl_event arg12); +public static native int clEnqueueCopyBufferToImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("size_t") long arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); +public static native int clEnqueueCopyImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); +public static native int clEnqueueCopyImageToBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); +public static native void clEnqueueMapBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8, IntPointer arg9); +public static native void clEnqueueMapBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8, IntBuffer arg9); +public static native void clEnqueueMapBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8, int[] arg9); +public static native void clEnqueueMapImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t*") SizeTPointer arg6, @Cast("size_t*") SizeTPointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10, IntPointer arg11); +public static native void clEnqueueMapImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t*") SizeTPointer arg6, @Cast("size_t*") SizeTPointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10, IntBuffer arg11); +public static native void clEnqueueMapImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t*") SizeTPointer arg6, @Cast("size_t*") SizeTPointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10, int[] arg11); +public static native int clEnqueueMarker(@ByVal cl_command_queue arg0, cl_event arg1); +public static native int clEnqueueNDRangeKernel(@ByVal cl_command_queue arg0, @ByVal cl_kernel arg1, @Cast("unsigned int") int arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); +public static native int clEnqueueReadBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, Pointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); +public static native int clEnqueueReadBufferRect(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, @Cast("size_t") long arg8, @Cast("size_t") long arg9, Pointer arg10, @Cast("unsigned int") int arg11, @Const cl_event arg12, cl_event arg13); +public static native int clEnqueueReadImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, Pointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10); +public static native int clEnqueueTask(@ByVal cl_command_queue arg0, @ByVal cl_kernel arg1, @Cast("unsigned int") int arg2, @Const cl_event arg3, cl_event arg4); +public static native int clEnqueueUnmapMemObject(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, Pointer arg2, @Cast("unsigned int") int arg3, @Const cl_event arg4, cl_event arg5); +public static native int clEnqueueWaitForEvents(@ByVal cl_command_queue arg0, @Cast("unsigned int") int arg1, @Const cl_event arg2); +public static native int clEnqueueWriteBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Const Pointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); +public static native int clEnqueueWriteBufferRect(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, @Cast("size_t") long arg8, @Cast("size_t") long arg9, @Const Pointer arg10, @Cast("unsigned int") int arg11, @Const cl_event arg12, cl_event arg13); +public static native int clEnqueueWriteImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, @Const Pointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10); +public static native int clFinish(@ByVal cl_command_queue arg0); +public static native int clFlush(@ByVal cl_command_queue arg0); +public static native int clGetCommandQueueInfo(@ByVal cl_command_queue arg0, @Cast("cl_command_queue_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetContextInfo(@ByVal cl_context arg0, @Cast("cl_context_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetDeviceIDs(@ByVal cl_platform_id arg0, @Cast("cl_device_type") long arg1, @Cast("unsigned int") int arg2, cl_device_id arg3, @Cast("unsigned int*") IntPointer arg4); +public static native int clGetDeviceIDs(@ByVal cl_platform_id arg0, @Cast("cl_device_type") long arg1, @Cast("unsigned int") int arg2, cl_device_id arg3, @Cast("unsigned int*") IntBuffer arg4); +public static native int clGetDeviceIDs(@ByVal cl_platform_id arg0, @Cast("cl_device_type") long arg1, @Cast("unsigned int") int arg2, cl_device_id arg3, @Cast("unsigned int*") int[] arg4); +public static native int clGetDeviceInfo(@ByVal cl_device_id arg0, @Cast("cl_device_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetEventInfo(@ByVal cl_event arg0, @Cast("cl_event_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetEventProfilingInfo(@ByVal cl_event arg0, @Cast("cl_profiling_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native void clGetExtensionFunctionAddress(@Cast("const char*") BytePointer arg0); +public static native void clGetExtensionFunctionAddress(String arg0); +public static native int clGetImageInfo(@ByVal cl_mem arg0, @Cast("cl_image_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetKernelInfo(@ByVal cl_kernel arg0, @Cast("cl_kernel_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetKernelWorkGroupInfo(@ByVal cl_kernel arg0, @ByVal cl_device_id arg1, @Cast("cl_kernel_work_group_info") int arg2, @Cast("size_t") long arg3, Pointer arg4, @Cast("size_t*") SizeTPointer arg5); +public static native int clGetMemObjectInfo(@ByVal cl_mem arg0, @Cast("cl_mem_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetPlatformIDs(@Cast("unsigned int") int arg0, cl_platform_id arg1, @Cast("unsigned int*") IntPointer arg2); +public static native int clGetPlatformIDs(@Cast("unsigned int") int arg0, cl_platform_id arg1, @Cast("unsigned int*") IntBuffer arg2); +public static native int clGetPlatformIDs(@Cast("unsigned int") int arg0, cl_platform_id arg1, @Cast("unsigned int*") int[] arg2); +public static native int clGetPlatformInfo(@ByVal cl_platform_id arg0, @Cast("cl_platform_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetProgramBuildInfo(@ByVal cl_program arg0, @ByVal cl_device_id arg1, @Cast("cl_program_build_info") int arg2, @Cast("size_t") long arg3, Pointer arg4, @Cast("size_t*") SizeTPointer arg5); +public static native int clGetProgramInfo(@ByVal cl_program arg0, @Cast("cl_program_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetSamplerInfo(@ByVal cl_sampler arg0, @Cast("cl_sampler_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); +public static native int clGetSupportedImageFormats(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_mem_object_type") int arg2, @Cast("unsigned int") int arg3, cl_image_format arg4, @Cast("unsigned int*") IntPointer arg5); +public static native int clGetSupportedImageFormats(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_mem_object_type") int arg2, @Cast("unsigned int") int arg3, cl_image_format arg4, @Cast("unsigned int*") IntBuffer arg5); +public static native int clGetSupportedImageFormats(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_mem_object_type") int arg2, @Cast("unsigned int") int arg3, cl_image_format arg4, @Cast("unsigned int*") int[] arg5); +public static native int clReleaseCommandQueue(@ByVal cl_command_queue arg0); +public static native int clReleaseContext(@ByVal cl_context arg0); +public static native int clReleaseEvent(@ByVal cl_event arg0); +public static native int clReleaseKernel(@ByVal cl_kernel arg0); +public static native int clReleaseMemObject(@ByVal cl_mem arg0); +public static native int clReleaseProgram(@ByVal cl_program arg0); +public static native int clReleaseSampler(@ByVal cl_sampler arg0); +public static native int clRetainCommandQueue(@ByVal cl_command_queue arg0); +public static native int clRetainContext(@ByVal cl_context arg0); +public static native int clRetainEvent(@ByVal cl_event arg0); +public static native int clRetainKernel(@ByVal cl_kernel arg0); +public static native int clRetainMemObject(@ByVal cl_mem arg0); +public static native int clRetainProgram(@ByVal cl_program arg0); +public static native int clRetainSampler(@ByVal cl_sampler arg0); +// cl_int clSetCommandQueueProperty(cl_command_queue /* command_queue */, cl_command_queue_properties /* properties */, cl_bool /* enable */, cl_command_queue_properties * /* old_properties */); +public static native int clSetKernelArg(@ByVal cl_kernel arg0, @Cast("unsigned int") int arg1, @Cast("size_t") long arg2, @Const Pointer arg3); +public static native int clSetUserEventStatus(@ByVal cl_event arg0, int arg1); +public static native int clUnloadCompiler(); +public static native int clWaitForEvents(@Cast("unsigned int") int arg0, @Const cl_event arg1); + +// #endif // XXXXXXXXXX + + +} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java index 13affa6bec1..c40a7642478 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java @@ -15,6 +15,7 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import static org.bytedeco.bullet.clew.*; public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL { static { Loader.load(); } @@ -137,9 +138,9 @@ public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL {

* CL Context optionally takes a GL context. This is a generic type because we don't really want this code * to have to understand GL types. It is a HGLRC in _WIN32 or a GLXContext otherwise. */ - public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(int deviceType, IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(int deviceType, IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(int deviceType, int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); public static native int b3OpenCLUtils_getNumDevices(@ByVal cl_context cxMainContext); @@ -180,9 +181,9 @@ public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL { public static native void b3OpenCLUtils_setCachePath(@Cast("const char*") BytePointer path); public static native void b3OpenCLUtils_setCachePath(String path); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, int deviceType, int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); // #ifdef __cplusplus From d11e27d42edf231e596e9f96e49992cb5e6411c2 Mon Sep 17 00:00:00 2001 From: Andrey Krainyak Date: Thu, 24 Mar 2022 10:29:07 +0800 Subject: [PATCH 77/81] Preload Bullet3Geometry.so Required by Bullet3Collision library. --- .../java/org/bytedeco/bullet/presets/Bullet3Collision.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java index 11a82ca59b7..ea67bceaef5 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java @@ -63,7 +63,8 @@ "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h", "Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h", }, - link = "Bullet3Collision@.3.20" + link = "Bullet3Collision@.3.20", + preload = "Bullet3Geometry@.3.20" ), @Platform(value = "windows", link = { "Bullet3Collision@.3.20", "Bullet3Geometry@.3.20" }) }, From 182632497d684b0519ed47392a9505dd1fc9c86d Mon Sep 17 00:00:00 2001 From: Samuel Audet Date: Sat, 26 Mar 2022 08:04:05 +0900 Subject: [PATCH 78/81] Fix module-info.java --- bullet/src/main/java9/module-info.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 95308a14fab..0a4b0eccbf0 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -1,6 +1,6 @@ module org.bytedeco.bullet { requires transitive org.bytedeco.javacpp; - exports org.bytedeco.bullet.clew; + exports org.bytedeco.bullet; exports org.bytedeco.bullet.global; exports org.bytedeco.bullet.presets; exports org.bytedeco.bullet.LinearMath; From 737428e69189f3b600045665623bc9858dcc56f0 Mon Sep 17 00:00:00 2001 From: Samuel Audet Date: Sat, 26 Mar 2022 10:26:07 +0900 Subject: [PATCH 79/81] Fix build on Mac --- bullet/cppbuild.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/bullet/cppbuild.sh b/bullet/cppbuild.sh index e72099be73f..6deaef77f0d 100755 --- a/bullet/cppbuild.sh +++ b/bullet/cppbuild.sh @@ -215,7 +215,7 @@ case $PLATFORM in ;; esac -sed -i "s/\(typedef.*btSolverCallback.*;\)/public: \1 private:/g" \ +sedinplace "s/\(typedef.*btSolverCallback.*;\)/public: \1 private:/g" \ ${INSTALL_PATH}/include/bullet/BulletSoftBody/btDeformableMultiBodyDynamicsWorld.h cd ../../.. From 0d9716f85df99be9cc3e3f848ea6e7aa06201d1e Mon Sep 17 00:00:00 2001 From: Samuel Audet Date: Sun, 27 Mar 2022 07:59:31 +0900 Subject: [PATCH 80/81] Remove mappings for clew --- bullet/gen-clew-stubs | 84 - .../bullet/Bullet3OpenCL/GpuSatCollision.java | 51 +- .../bullet/Bullet3OpenCL/b3AabbOCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3BoundSearchCL.java | 17 +- .../bullet/Bullet3OpenCL/b3BufferInfoCL.java | 13 +- .../bullet/Bullet3OpenCL/b3BvhInfo.java | 1 - .../bullet/Bullet3OpenCL/b3BvhInfoArray.java | 1 - .../Bullet3OpenCL/b3BvhInfoOCLArray.java | 17 +- .../Bullet3OpenCL/b3BvhSubtreeInfo.java | 1 - .../Bullet3OpenCL/b3BvhSubtreeInfoArray.java | 1 - .../b3BvhSubtreeInfoOCLArray.java | 17 +- .../Bullet3OpenCL/b3CharIndexTripletData.java | 1 - .../Bullet3OpenCL/b3CollidableOCLArray.java | 17 +- .../b3CompoundOverlappingPairArray.java | 1 - .../b3CompoundOverlappingPairOCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3Contact4Array.java | 1 - .../Bullet3OpenCL/b3Contact4OCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3ContactPoint.java | 1 - .../b3ConvexPolyhedronDataOCLArray.java | 17 +- .../Bullet3OpenCL/b3ConvexUtilityArray.java | 1 - .../bullet/Bullet3OpenCL/b3Dispatcher.java | 1 - .../bullet/Bullet3OpenCL/b3FillCL.java | 5 +- .../bullet/Bullet3OpenCL/b3FloatOCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3GjkEpaSolver2.java | 1 - .../Bullet3OpenCL/b3GjkPairDetector.java | 1 - .../b3GpuBroadphaseInterface.java | 5 +- .../b3GpuChildShapeOCLArray.java | 17 +- .../Bullet3OpenCL/b3GpuConstraint4.java | 1 - .../Bullet3OpenCL/b3GpuConstraint4Array.java | 1 - .../b3GpuConstraint4OCLArray.java | 17 +- .../Bullet3OpenCL/b3GpuConstraintInfo2.java | 1 - .../Bullet3OpenCL/b3GpuFaceOCLArray.java | 17 +- .../Bullet3OpenCL/b3GpuGenericConstraint.java | 1 - .../b3GpuGenericConstraintArray.java | 1 - .../b3GpuGenericConstraintOCLArray.java | 17 +- .../Bullet3OpenCL/b3GpuGridBroadphase.java | 11 +- .../b3GpuJacobiContactSolver.java | 7 +- .../Bullet3OpenCL/b3GpuNarrowPhase.java | 17 +- .../b3GpuNarrowPhaseInternalData.java | 1 - .../Bullet3OpenCL/b3GpuParallelLinearBvh.java | 5 +- .../b3GpuParallelLinearBvhBroadphase.java | 11 +- .../b3GpuPgsConstraintSolver.java | 5 +- .../Bullet3OpenCL/b3GpuPgsContactSolver.java | 7 +- .../bullet/Bullet3OpenCL/b3GpuRaycast.java | 5 +- .../Bullet3OpenCL/b3GpuRigidBodyPipeline.java | 7 +- .../b3GpuRigidBodyPipelineInternalData.java | 13 +- .../Bullet3OpenCL/b3GpuSapBroadphase.java | 23 +- .../bullet/Bullet3OpenCL/b3GpuSolverBody.java | 1 - .../Bullet3OpenCL/b3GpuSolverConstraint.java | 1 - .../bullet/Bullet3OpenCL/b3IndexedMesh.java | 1 - .../Bullet3OpenCL/b3InertiaDataArray.java | 1 - .../Bullet3OpenCL/b3InertiaDataOCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3Int2OCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3Int4OCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3IntIndexData.java | 1 - .../bullet/Bullet3OpenCL/b3IntOCLArray.java | 17 +- .../b3InternalTriangleIndexCallback.java | 1 - .../Bullet3OpenCL/b3JacobiSolverInfo.java | 1 - .../bullet/Bullet3OpenCL/b3KernelArgData.java | 3 +- .../bullet/Bullet3OpenCL/b3LauncherCL.java | 17 +- .../bullet/Bullet3OpenCL/b3MeshPartData.java | 1 - .../Bullet3OpenCL/b3NodeOverlapCallback.java | 1 - .../Bullet3OpenCL/b3OpenCLDeviceInfo.java | 35 +- .../Bullet3OpenCL/b3OpenCLPlatformInfo.java | 1 - .../bullet/Bullet3OpenCL/b3OpenCLUtils.java | 83 +- .../bullet/Bullet3OpenCL/b3OptimizedBvh.java | 1 - .../Bullet3OpenCL/b3OptimizedBvhArray.java | 1 - .../Bullet3OpenCL/b3OptimizedBvhNode.java | 1 - .../b3OptimizedBvhNodeDoubleData.java | 1 - .../b3OptimizedBvhNodeFloatData.java | 1 - .../b3ParamsGridBroadphaseCL.java | 1 - .../Bullet3OpenCL/b3PrefixScanFloat4CL.java | 9 +- .../bullet/Bullet3OpenCL/b3QuantizedBvh.java | 1 - .../b3QuantizedBvhDoubleData.java | 1 - .../b3QuantizedBvhFloatData.java | 1 - .../Bullet3OpenCL/b3QuantizedBvhNode.java | 1 - .../b3QuantizedBvhNodeArray.java | 1 - .../b3QuantizedBvhNodeOCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3RadixSort32CL.java | 9 +- .../Bullet3OpenCL/b3RayInfoOCLArray.java | 17 +- .../b3RigidBodyDataOCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3SapAabb.java | 1 - .../bullet/Bullet3OpenCL/b3SapAabbArray.java | 1 - .../Bullet3OpenCL/b3SapAabbOCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3Serializer.java | 1 - .../Bullet3OpenCL/b3ShortIntIndexData.java | 1 - .../b3ShortIntIndexTripletData.java | 1 - .../bullet/Bullet3OpenCL/b3Solver.java | 27 +- .../bullet/Bullet3OpenCL/b3SolverBase.java | 1 - .../bullet/Bullet3OpenCL/b3SortData.java | 1 - .../bullet/Bullet3OpenCL/b3SortDataArray.java | 1 - .../Bullet3OpenCL/b3SortDataOCLArray.java | 17 +- .../b3StridingMeshInterface.java | 1 - .../b3StridingMeshInterfaceData.java | 1 - .../b3SubSimplexClosestResult.java | 1 - .../Bullet3OpenCL/b3TriangleCallback.java | 1 - .../b3TriangleIndexVertexArray.java | 1 - .../b3TriangleIndexVertexArrayArray.java | 1 - .../Bullet3OpenCL/b3UnsignedCharOCLArray.java | 17 +- .../b3UnsignedCharOCLArrayArray.java | 1 - .../Bullet3OpenCL/b3UnsignedIntOCLArray.java | 17 +- .../bullet/Bullet3OpenCL/b3UsageBitfield.java | 1 - .../Bullet3OpenCL/b3Vector3OCLArray.java | 17 +- .../Bullet3OpenCL/b3VoronoiSimplexSolver.java | 1 - .../gen/java/org/bytedeco/bullet/clew.java | 2015 ----------------- .../bytedeco/bullet/global/Bullet3OpenCL.java | 57 +- .../bullet/presets/Bullet3OpenCL.java | 25 +- .../org/bytedeco/bullet/presets/clew.java | 172 -- .../org/bytedeco/bullet/include/clew_stubs.h | 120 - 109 files changed, 424 insertions(+), 2898 deletions(-) delete mode 100755 bullet/gen-clew-stubs delete mode 100644 bullet/src/gen/java/org/bytedeco/bullet/clew.java delete mode 100644 bullet/src/main/java/org/bytedeco/bullet/presets/clew.java delete mode 100644 bullet/src/main/resources/org/bytedeco/bullet/include/clew_stubs.h diff --git a/bullet/gen-clew-stubs b/bullet/gen-clew-stubs deleted file mode 100755 index 2a173b8a6a4..00000000000 --- a/bullet/gen-clew-stubs +++ /dev/null @@ -1,84 +0,0 @@ -#!/usr/bin/env hy - -;; -;; Copyright (C) 2022 Andrey Krainyak -;; -;; Licensed either under the Apache License, Version 2.0, or (at your option) -;; under the terms of the GNU General Public License as published by -;; the Free Software Foundation (subject to the "Classpath" exception), -;; either version 2, or any later version (collectively, the "License"); -;; you may not use this file except in compliance with the License. -;; You may obtain a copy of the License at -;; -;; http://www.apache.org/licenses/LICENSE-2.0 -;; http://www.gnu.org/licenses/ -;; http://www.gnu.org/software/classpath/license.html -;; -;; or as provided in the LICENSE.txt file that accompanied this code. -;; Unless required by applicable law or agreed to in writing, software -;; distributed under the License is distributed on an "AS IS" BASIS, -;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -;; See the License for the specific language governing permissions and -;; limitations under the License. -;; - - - -;; Usage: - -;; Install dependencies: pip install --pre hy hyrule -;; Invoke the script from terminal - it will spit out the stubs into stdout. -;; Copy the output into clew_stubs.h inside bullet/src/main/resources. - -(import glob [glob]) -(import pathlib [Path]) -(import re) -(require hyrule [-> ->>] - hyrule.anaphoric * - hyrule.destructure [let+]) - -(setv SCRIPT-PATH (Path __file__)) -(setv BULLET-DIR (. SCRIPT-PATH parent)) -(setv CLEW-H-PATH (get (glob f"{BULLET-DIR}/**/clew.h" :recursive True) 0)) - -(defn read-header [] - (with [f (open CLEW-H-PATH "r")] - (f.read))) - -(defn extract-func-names [header-text] - (->> header-text - (re.findall "#define *(\w+) *CLEW_GET_FUN.*\n"))) - -(defn parse-params [text] - (->> text - (re.sub "[\n\t]" " ") - (re.sub " +" " "))) - -(defn parse-typedef [text] - (let [groups (re.search (+ "(?s)CL_API_ENTRY *" - "(?P\w+).*" - "(?PPFN\w+)\)" - "\((?P.*)\)") text)] - (, (.group groups "pfn") - {"params" (parse-params (.group groups "params")) - "ret-type" (.group groups "rettype")}))) - -(defn extract-typedefs [header-text] - (->> header-text - (re.findall "(?s)typedef CL_API_ENTRY.*?;") - (map parse-typedef) - dict)) - -(defn gen-fun-decl [name typedefs] - (let+ [pfn (+ "PFN" (.upper name)) - {ret "ret-type" ps "params"} (get typedefs pfn)] - f"{ret} {name}({ps});")) - -(let [header-text (read-header) - typedefs (extract-typedefs header-text)] - (->> header-text - extract-func-names - sorted - (map #%(gen-fun-decl %1 typedefs)) - (.join "\n") - print)) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java index 53bd4d9e1f1..ea2506320bc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -26,38 +25,38 @@ public class GpuSatCollision extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public GpuSatCollision(Pointer p) { super(p); } - public native @ByRef cl_context m_context(); public native GpuSatCollision m_context(cl_context setter); - public native @ByRef cl_device_id m_device(); public native GpuSatCollision m_device(cl_device_id setter); - public native @ByRef cl_command_queue m_queue(); public native GpuSatCollision m_queue(cl_command_queue setter); - public native @ByRef cl_kernel m_findSeparatingAxisKernel(); public native GpuSatCollision m_findSeparatingAxisKernel(cl_kernel setter); - public native @ByRef cl_kernel m_mprPenetrationKernel(); public native GpuSatCollision m_mprPenetrationKernel(cl_kernel setter); - public native @ByRef cl_kernel m_findSeparatingAxisUnitSphereKernel(); public native GpuSatCollision m_findSeparatingAxisUnitSphereKernel(cl_kernel setter); + public native @Cast("cl_context") Pointer m_context(); public native GpuSatCollision m_context(Pointer setter); + public native @Cast("cl_device_id") Pointer m_device(); public native GpuSatCollision m_device(Pointer setter); + public native @Cast("cl_command_queue") Pointer m_queue(); public native GpuSatCollision m_queue(Pointer setter); + public native @Cast("cl_kernel") Pointer m_findSeparatingAxisKernel(); public native GpuSatCollision m_findSeparatingAxisKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_mprPenetrationKernel(); public native GpuSatCollision m_mprPenetrationKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_findSeparatingAxisUnitSphereKernel(); public native GpuSatCollision m_findSeparatingAxisUnitSphereKernel(Pointer setter); - public native @ByRef cl_kernel m_findSeparatingAxisVertexFaceKernel(); public native GpuSatCollision m_findSeparatingAxisVertexFaceKernel(cl_kernel setter); - public native @ByRef cl_kernel m_findSeparatingAxisEdgeEdgeKernel(); public native GpuSatCollision m_findSeparatingAxisEdgeEdgeKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_findSeparatingAxisVertexFaceKernel(); public native GpuSatCollision m_findSeparatingAxisVertexFaceKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_findSeparatingAxisEdgeEdgeKernel(); public native GpuSatCollision m_findSeparatingAxisEdgeEdgeKernel(Pointer setter); - public native @ByRef cl_kernel m_findConcaveSeparatingAxisKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisKernel(cl_kernel setter); - public native @ByRef cl_kernel m_findConcaveSeparatingAxisVertexFaceKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisVertexFaceKernel(cl_kernel setter); - public native @ByRef cl_kernel m_findConcaveSeparatingAxisEdgeEdgeKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisEdgeEdgeKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_findConcaveSeparatingAxisKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_findConcaveSeparatingAxisVertexFaceKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisVertexFaceKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_findConcaveSeparatingAxisEdgeEdgeKernel(); public native GpuSatCollision m_findConcaveSeparatingAxisEdgeEdgeKernel(Pointer setter); - public native @ByRef cl_kernel m_findCompoundPairsKernel(); public native GpuSatCollision m_findCompoundPairsKernel(cl_kernel setter); - public native @ByRef cl_kernel m_processCompoundPairsKernel(); public native GpuSatCollision m_processCompoundPairsKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_findCompoundPairsKernel(); public native GpuSatCollision m_findCompoundPairsKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_processCompoundPairsKernel(); public native GpuSatCollision m_processCompoundPairsKernel(Pointer setter); - public native @ByRef cl_kernel m_clipHullHullKernel(); public native GpuSatCollision m_clipHullHullKernel(cl_kernel setter); - public native @ByRef cl_kernel m_clipCompoundsHullHullKernel(); public native GpuSatCollision m_clipCompoundsHullHullKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_clipHullHullKernel(); public native GpuSatCollision m_clipHullHullKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_clipCompoundsHullHullKernel(); public native GpuSatCollision m_clipCompoundsHullHullKernel(Pointer setter); - public native @ByRef cl_kernel m_clipFacesAndFindContacts(); public native GpuSatCollision m_clipFacesAndFindContacts(cl_kernel setter); - public native @ByRef cl_kernel m_findClippingFacesKernel(); public native GpuSatCollision m_findClippingFacesKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_clipFacesAndFindContacts(); public native GpuSatCollision m_clipFacesAndFindContacts(Pointer setter); + public native @Cast("cl_kernel") Pointer m_findClippingFacesKernel(); public native GpuSatCollision m_findClippingFacesKernel(Pointer setter); - public native @ByRef cl_kernel m_clipHullHullConcaveConvexKernel(); public native GpuSatCollision m_clipHullHullConcaveConvexKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_clipHullHullConcaveConvexKernel(); public native GpuSatCollision m_clipHullHullConcaveConvexKernel(Pointer setter); // cl_kernel m_extractManifoldAndAddContactKernel; - public native @ByRef cl_kernel m_newContactReductionKernel(); public native GpuSatCollision m_newContactReductionKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_newContactReductionKernel(); public native GpuSatCollision m_newContactReductionKernel(Pointer setter); - public native @ByRef cl_kernel m_bvhTraversalKernel(); public native GpuSatCollision m_bvhTraversalKernel(cl_kernel setter); - public native @ByRef cl_kernel m_primitiveContactsKernel(); public native GpuSatCollision m_primitiveContactsKernel(cl_kernel setter); - public native @ByRef cl_kernel m_findConcaveSphereContactsKernel(); public native GpuSatCollision m_findConcaveSphereContactsKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_bvhTraversalKernel(); public native GpuSatCollision m_bvhTraversalKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_primitiveContactsKernel(); public native GpuSatCollision m_primitiveContactsKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_findConcaveSphereContactsKernel(); public native GpuSatCollision m_findConcaveSphereContactsKernel(Pointer setter); - public native @ByRef cl_kernel m_processCompoundPairsPrimitivesKernel(); public native GpuSatCollision m_processCompoundPairsPrimitivesKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_processCompoundPairsPrimitivesKernel(); public native GpuSatCollision m_processCompoundPairsPrimitivesKernel(Pointer setter); @@ -75,8 +74,8 @@ public class GpuSatCollision extends Pointer { - public GpuSatCollision(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q) { super((Pointer)null); allocate(ctx, device, q); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public GpuSatCollision(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q) { super((Pointer)null); allocate(ctx, device, q); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); public native void computeConvexConvexContactsGPUSAT(b3Int4OCLArray pairs, int nPairs, @Const b3RigidBodyDataOCLArray bodyBuf, diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java index f4416e71410..6dd6d12d149 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3AabbOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3AabbOCLArray(Pointer p) { super(p); } - public b3AabbOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3AabbOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3AabbOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3AabbOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3AabbOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3Aabb _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3Aabb _Val); @@ -58,8 +57,8 @@ public class b3AabbOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3AabbArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3AabbArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java index 9539dcdd679..ae50b7bf885 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; //for b3SortData (perhaps move it?) @@ -29,13 +28,13 @@ public class b3BoundSearchCL extends Pointer { BOUND_UPPER = 1, COUNT = 2; - public native @ByRef cl_context m_context(); public native b3BoundSearchCL m_context(cl_context setter); - public native @ByRef cl_device_id m_device(); public native b3BoundSearchCL m_device(cl_device_id setter); - public native @ByRef cl_command_queue m_queue(); public native b3BoundSearchCL m_queue(cl_command_queue setter); + public native @Cast("cl_context") Pointer m_context(); public native b3BoundSearchCL m_context(Pointer setter); + public native @Cast("cl_device_id") Pointer m_device(); public native b3BoundSearchCL m_device(Pointer setter); + public native @Cast("cl_command_queue") Pointer m_queue(); public native b3BoundSearchCL m_queue(Pointer setter); - public native @ByRef cl_kernel m_lowerSortDataKernel(); public native b3BoundSearchCL m_lowerSortDataKernel(cl_kernel setter); - public native @ByRef cl_kernel m_upperSortDataKernel(); public native b3BoundSearchCL m_upperSortDataKernel(cl_kernel setter); - public native @ByRef cl_kernel m_subtractKernel(); public native b3BoundSearchCL m_subtractKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_lowerSortDataKernel(); public native b3BoundSearchCL m_lowerSortDataKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_upperSortDataKernel(); public native b3BoundSearchCL m_upperSortDataKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_subtractKernel(); public native b3BoundSearchCL m_subtractKernel(Pointer setter); public native b3Int4OCLArray m_constbtOpenCLArray(); public native b3BoundSearchCL m_constbtOpenCLArray(b3Int4OCLArray setter); public native b3UnsignedIntOCLArray m_lower(); public native b3BoundSearchCL m_lower(b3UnsignedIntOCLArray setter); @@ -43,8 +42,8 @@ public class b3BoundSearchCL extends Pointer { public native b3FillCL m_filler(); public native b3BoundSearchCL m_filler(b3FillCL setter); - public b3BoundSearchCL(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int size) { super((Pointer)null); allocate(context, device, queue, size); } - private native void allocate(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int size); + public b3BoundSearchCL(@Cast("cl_context") Pointer context, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int size) { super((Pointer)null); allocate(context, device, queue, size); } + private native void allocate(@Cast("cl_context") Pointer context, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int size); // src has to be src[i].m_key <= src[i+1].m_key public native void execute(@ByRef b3SortDataOCLArray src, int nSrc, @ByRef b3UnsignedIntOCLArray dst, int nDst, @Cast("b3BoundSearchCL::Option") int option/*=b3BoundSearchCL::BOUND_LOWER*/); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java index dbf0433a3a4..8cda64e2a51 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -21,17 +20,15 @@ @NoOffset @Properties(inherit = org.bytedeco.bullet.presets.Bullet3OpenCL.class) public class b3BufferInfoCL extends Pointer { static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public b3BufferInfoCL(Pointer p) { super(p); } //b3BufferInfoCL(){} // template - public b3BufferInfoCL(@ByVal cl_mem buff, @Cast("bool") boolean isReadOnly/*=false*/) { super((Pointer)null); allocate(buff, isReadOnly); } - private native void allocate(@ByVal cl_mem buff, @Cast("bool") boolean isReadOnly/*=false*/); - public b3BufferInfoCL(@ByVal cl_mem buff) { super((Pointer)null); allocate(buff); } - private native void allocate(@ByVal cl_mem buff); + public b3BufferInfoCL(@Cast("cl_mem") Pointer buff, @Cast("bool") boolean isReadOnly/*=false*/) { super((Pointer)null); allocate(buff, isReadOnly); } + private native void allocate(@Cast("cl_mem") Pointer buff, @Cast("bool") boolean isReadOnly/*=false*/); + public b3BufferInfoCL(@Cast("cl_mem") Pointer buff) { super((Pointer)null); allocate(buff); } + private native void allocate(@Cast("cl_mem") Pointer buff); - public native @ByRef cl_mem m_clBuffer(); public native b3BufferInfoCL m_clBuffer(cl_mem setter); + public native @Cast("cl_mem") Pointer m_clBuffer(); public native b3BufferInfoCL m_clBuffer(Pointer setter); public native @Cast("bool") boolean m_isReadOnly(); public native b3BufferInfoCL m_isReadOnly(boolean setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java index 74936d1d80b..1e052b2c0f6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java index 69d62d7f029..23a74e7cb51 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java index 04846dc0d74..dbdfe2de330 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3BvhInfoOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3BvhInfoOCLArray(Pointer p) { super(p); } - public b3BvhInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3BvhInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3BvhInfoOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3BvhInfoOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3BvhInfoOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3BvhInfo _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3BvhInfo _Val); @@ -58,8 +57,8 @@ public class b3BvhInfoOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3BvhInfoArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3BvhInfoArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java index 23e53ac5c5d..b933b2750d1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java index 9c760d5d828..7f05bdfcd96 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java index e59d13ad67b..8ff0b7a25e3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3BvhSubtreeInfoOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3BvhSubtreeInfoOCLArray(Pointer p) { super(p); } - public b3BvhSubtreeInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3BvhSubtreeInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3BvhSubtreeInfoOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3BvhSubtreeInfoOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3BvhSubtreeInfoOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3BvhSubtreeInfo _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3BvhSubtreeInfo _Val); @@ -58,8 +57,8 @@ public class b3BvhSubtreeInfoOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3BvhSubtreeInfoArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3BvhSubtreeInfoArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java index f42d49c428a..d4a9ca5d283 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java index bee5f4a061d..cbd59db3274 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3CollidableOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3CollidableOCLArray(Pointer p) { super(p); } - public b3CollidableOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3CollidableOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3CollidableOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3CollidableOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3CollidableOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3Collidable _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3Collidable _Val); @@ -58,8 +57,8 @@ public class b3CollidableOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3CollidableArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3CollidableArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java index 12edc3578b4..e326e492734 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java index 211793a1988..dcf5f35a630 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3CompoundOverlappingPairOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3CompoundOverlappingPairOCLArray(Pointer p) { super(p); } - public b3CompoundOverlappingPairOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3CompoundOverlappingPairOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3CompoundOverlappingPairOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3CompoundOverlappingPairOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3CompoundOverlappingPairOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3CompoundOverlappingPair _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3CompoundOverlappingPair _Val); @@ -58,8 +57,8 @@ public class b3CompoundOverlappingPairOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3CompoundOverlappingPairArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3CompoundOverlappingPairArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java index 078bf9d3b79..df7f91e92f4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java index a94857989fa..83ab086ef55 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3Contact4OCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3Contact4OCLArray(Pointer p) { super(p); } - public b3Contact4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3Contact4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3Contact4OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3Contact4OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3Contact4OCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3Contact4 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3Contact4 _Val); @@ -58,8 +57,8 @@ public class b3Contact4OCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3Contact4Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3Contact4Array srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java index 9b2a5c88830..aa12e14a847 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java index dd23a543f9d..0f86b8f7bb8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3ConvexPolyhedronDataOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3ConvexPolyhedronDataOCLArray(Pointer p) { super(p); } - public b3ConvexPolyhedronDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3ConvexPolyhedronDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3ConvexPolyhedronDataOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3ConvexPolyhedronDataOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3ConvexPolyhedronDataOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3ConvexPolyhedronData _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3ConvexPolyhedronData _Val); @@ -58,8 +57,8 @@ public class b3ConvexPolyhedronDataOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3ConvexPolyhedronDataArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3ConvexPolyhedronDataArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java index 8198512a9de..a7613b9e97b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; //for placement new diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java index 9f265236f7a..05598b353dc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java index b016264ce2b..7ca1af8641a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -48,8 +47,8 @@ public static class b3ConstData extends Pointer { public native int m_padding(int i); public native b3ConstData m_padding(int i, int setter); @MemberGetter public native IntPointer m_padding(); } - public b3FillCL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, device, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + public b3FillCL(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, device, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue); public native void execute(@ByRef b3UnsignedIntOCLArray src, @Cast("const unsigned int") int value, int n, int offset/*=0*/); public native void execute(@ByRef b3UnsignedIntOCLArray src, @Cast("const unsigned int") int value, int n); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java index 7702ddba5ca..e343f6acf49 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3FloatOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3FloatOCLArray(Pointer p) { super(p); } - public b3FloatOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3FloatOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3FloatOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3FloatOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3FloatOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(float _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(float _Val); @@ -58,8 +57,8 @@ public class b3FloatOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3FloatArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3FloatArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java index 05a4528ee42..de6030f5c5d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java index 58cce78c75a..8ffac19a80e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java index 31841db25c1..fdc4c85d500 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -34,9 +33,9 @@ public class b3GpuBroadphaseInterface extends Pointer { //call writeAabbsToGpu after done making all changes (createProxy etc) public native void writeAabbsToGpu(); - public native @ByVal cl_mem getAabbBufferWS(); + public native @Cast("cl_mem") Pointer getAabbBufferWS(); public native int getNumOverlap(); - public native @ByVal cl_mem getOverlappingPairBuffer(); + public native @Cast("cl_mem") Pointer getOverlappingPairBuffer(); public native @ByRef b3SapAabbOCLArray getAllAabbsGPU(); public native @ByRef b3SapAabbArray getAllAabbsCPU(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java index 1405a07d73e..3f0536e04aa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3GpuChildShapeOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuChildShapeOCLArray(Pointer p) { super(p); } - public b3GpuChildShapeOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3GpuChildShapeOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3GpuChildShapeOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3GpuChildShapeOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3GpuChildShapeOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuChildShape _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuChildShape _Val); @@ -58,8 +57,8 @@ public class b3GpuChildShapeOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3GpuChildShapeArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3GpuChildShapeArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java index 0b3d2b1165b..6b2ee80997b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java index 507cd81fa9d..873335b0203 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java index b57a801275c..9ccf597885a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3GpuConstraint4OCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuConstraint4OCLArray(Pointer p) { super(p); } - public b3GpuConstraint4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3GpuConstraint4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3GpuConstraint4OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3GpuConstraint4OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3GpuConstraint4OCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuConstraint4 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuConstraint4 _Val); @@ -58,8 +57,8 @@ public class b3GpuConstraint4OCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3GpuConstraint4Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3GpuConstraint4Array srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java index 9ba572c968b..f50a69712fa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java index 35085c9d7bc..6ec46836651 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3GpuFaceOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuFaceOCLArray(Pointer p) { super(p); } - public b3GpuFaceOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3GpuFaceOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3GpuFaceOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3GpuFaceOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3GpuFaceOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuFace _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuFace _Val); @@ -58,8 +57,8 @@ public class b3GpuFaceOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3GpuFaceArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3GpuFaceArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java index 9731bfe5d33..4c39352fd3b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java index 0d10d309137..f6ad175ab5a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java index 157a1384e8b..4cd8e845920 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3GpuGenericConstraintOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuGenericConstraintOCLArray(Pointer p) { super(p); } - public b3GpuGenericConstraintOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3GpuGenericConstraintOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3GpuGenericConstraintOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3GpuGenericConstraintOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3GpuGenericConstraintOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuGenericConstraint _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3GpuGenericConstraint _Val); @@ -58,8 +57,8 @@ public class b3GpuGenericConstraintOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3GpuGenericConstraintArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3GpuGenericConstraintArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java index 65b2d68ddb7..82de98bed6c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,10 +23,10 @@ public class b3GpuGridBroadphase extends b3GpuBroadphaseInterface { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuGridBroadphase(Pointer p) { super(p); } - public b3GpuGridBroadphase(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q) { super((Pointer)null); allocate(ctx, device, q); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public b3GpuGridBroadphase(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q) { super((Pointer)null); allocate(ctx, device, q); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); - public static native b3GpuBroadphaseInterface CreateFunc(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public static native b3GpuBroadphaseInterface CreateFunc(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); public native void createProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); public native void createLargeProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); @@ -38,9 +37,9 @@ public class b3GpuGridBroadphase extends b3GpuBroadphaseInterface { //call writeAabbsToGpu after done making all changes (createProxy etc) public native void writeAabbsToGpu(); - public native @ByVal cl_mem getAabbBufferWS(); + public native @Cast("cl_mem") Pointer getAabbBufferWS(); public native int getNumOverlap(); - public native @ByVal cl_mem getOverlappingPairBuffer(); + public native @Cast("cl_mem") Pointer getOverlappingPairBuffer(); public native @ByRef b3SapAabbOCLArray getAllAabbsGPU(); public native @ByRef b3SapAabbArray getAllAabbsCPU(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java index 1392d8a3cf4..e75161ecc78 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -23,10 +22,10 @@ public class b3GpuJacobiContactSolver extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuJacobiContactSolver(Pointer p) { super(p); } - public b3GpuJacobiContactSolver(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int pairCapacity) { super((Pointer)null); allocate(ctx, device, queue, pairCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int pairCapacity); + public b3GpuJacobiContactSolver(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int pairCapacity) { super((Pointer)null); allocate(ctx, device, queue, pairCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int pairCapacity); - public native void solveContacts(int numBodies, @ByVal cl_mem bodyBuf, @ByVal cl_mem inertiaBuf, int numContacts, @ByVal cl_mem contactBuf, @Const @ByRef b3Config config, int static0Index); + public native void solveContacts(int numBodies, @Cast("cl_mem") Pointer bodyBuf, @Cast("cl_mem") Pointer inertiaBuf, int numContacts, @Cast("cl_mem") Pointer contactBuf, @Const @ByRef b3Config config, int static0Index); public native void solveGroupHost(b3RigidBodyData bodies, b3InertiaData inertias, int numBodies, b3Contact4 manifoldPtr, int numManifolds, @Const @ByRef b3JacobiSolverInfo solverInfo); //void solveGroupHost(btRigidBodyCL* bodies,b3InertiaData* inertias,int numBodies,btContact4* manifoldPtr, int numManifolds,btTypedConstraint** constraints,int numConstraints,const btJacobiSolverInfo& solverInfo); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java index 7f74823fdc0..fe09300779c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,8 +23,8 @@ public class b3GpuNarrowPhase extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuNarrowPhase(Pointer p) { super(p); } - public b3GpuNarrowPhase(@ByVal cl_context vtx, @ByVal cl_device_id dev, @ByVal cl_command_queue q, @Const @ByRef b3Config config) { super((Pointer)null); allocate(vtx, dev, q, config); } - private native void allocate(@ByVal cl_context vtx, @ByVal cl_device_id dev, @ByVal cl_command_queue q, @Const @ByRef b3Config config); + public b3GpuNarrowPhase(@Cast("cl_context") Pointer vtx, @Cast("cl_device_id") Pointer dev, @Cast("cl_command_queue") Pointer q, @Const @ByRef b3Config config) { super((Pointer)null); allocate(vtx, dev, q, config); } + private native void allocate(@Cast("cl_context") Pointer vtx, @Cast("cl_device_id") Pointer dev, @Cast("cl_command_queue") Pointer q, @Const @ByRef b3Config config); public native int registerSphereShape(float radius); public native int registerPlaneShape(@Const @ByRef b3Vector3 planeNormal, float planeConstant); @@ -63,18 +62,18 @@ public class b3GpuNarrowPhase extends Pointer { public native void setObjectVelocityCpu(FloatBuffer linVel, FloatBuffer angVel, int bodyIndex); public native void setObjectVelocityCpu(float[] linVel, float[] angVel, int bodyIndex); - public native void computeContacts(@ByVal cl_mem broadphasePairs, int numBroadphasePairs, @ByVal cl_mem aabbsWorldSpace, int numObjects); + public native void computeContacts(@Cast("cl_mem") Pointer broadphasePairs, int numBroadphasePairs, @Cast("cl_mem") Pointer aabbsWorldSpace, int numObjects); - public native @ByVal cl_mem getBodiesGpu(); + public native @Cast("cl_mem") Pointer getBodiesGpu(); public native @Const b3RigidBodyData getBodiesCpu(); //struct b3RigidBodyData* getBodiesCpu(); public native int getNumBodiesGpu(); - public native @ByVal cl_mem getBodyInertiasGpu(); + public native @Cast("cl_mem") Pointer getBodyInertiasGpu(); public native int getNumBodyInertiasGpu(); - public native @ByVal cl_mem getCollidablesGpu(); + public native @Cast("cl_mem") Pointer getCollidablesGpu(); public native @Const b3Collidable getCollidablesCpu(); public native int getNumCollidablesGpu(); @@ -82,10 +81,10 @@ public class b3GpuNarrowPhase extends Pointer { public native @Const b3Contact4 getContactsCPU(); - public native @ByVal cl_mem getContactsGpu(); + public native @Cast("cl_mem") Pointer getContactsGpu(); public native int getNumContactsGpu(); - public native @ByVal cl_mem getAabbLocalSpaceBufferGpu(); + public native @Cast("cl_mem") Pointer getAabbLocalSpaceBufferGpu(); public native int getNumRigidBodies(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java index 3fc1e13b057..ba02eb17354 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java index 9b9350e3dd4..4ce601b73da 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -42,8 +41,8 @@ public class b3GpuParallelLinearBvh extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuParallelLinearBvh(Pointer p) { super(p); } - public b3GpuParallelLinearBvh(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(context, device, queue); } - private native void allocate(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + public b3GpuParallelLinearBvh(@Cast("cl_context") Pointer context, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(context, device, queue); } + private native void allocate(@Cast("cl_context") Pointer context, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue); /**Must be called before any other function */ public native void build(@Const @ByRef b3SapAabbOCLArray worldSpaceAabbs, @Const @ByRef b3IntOCLArray smallAabbIndices, diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java index a23d8a636e3..a604bb0e6e4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,8 +23,8 @@ public class b3GpuParallelLinearBvhBroadphase extends b3GpuBroadphaseInterface { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuParallelLinearBvhBroadphase(Pointer p) { super(p); } - public b3GpuParallelLinearBvhBroadphase(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(context, device, queue); } - private native void allocate(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + public b3GpuParallelLinearBvhBroadphase(@Cast("cl_context") Pointer context, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(context, device, queue); } + private native void allocate(@Cast("cl_context") Pointer context, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue); public native void createProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); public native void createLargeProxy(@Const @ByRef b3Vector3 aabbMin, @Const @ByRef b3Vector3 aabbMax, int userPtr, int collisionFilterGroup, int collisionFilterMask); @@ -37,9 +36,9 @@ public class b3GpuParallelLinearBvhBroadphase extends b3GpuBroadphaseInterface { public native void writeAabbsToGpu(); public native int getNumOverlap(); - public native @ByVal cl_mem getOverlappingPairBuffer(); + public native @Cast("cl_mem") Pointer getOverlappingPairBuffer(); - public native @ByVal cl_mem getAabbBufferWS(); + public native @Cast("cl_mem") Pointer getAabbBufferWS(); public native @ByRef b3SapAabbOCLArray getAllAabbsGPU(); public native @ByRef b3Int4OCLArray getOverlappingPairsGPU(); @@ -48,5 +47,5 @@ public class b3GpuParallelLinearBvhBroadphase extends b3GpuBroadphaseInterface { public native @ByRef b3SapAabbArray getAllAabbsCPU(); - public static native b3GpuBroadphaseInterface CreateFunc(@ByVal cl_context context, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + public static native b3GpuBroadphaseInterface CreateFunc(@Cast("cl_context") Pointer context, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java index 2bd59e72d56..c61da377e68 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,8 +23,8 @@ public class b3GpuPgsConstraintSolver extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuPgsConstraintSolver(Pointer p) { super(p); } - public b3GpuPgsConstraintSolver(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, @Cast("bool") boolean usePgs) { super((Pointer)null); allocate(ctx, device, queue, usePgs); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, @Cast("bool") boolean usePgs); + public b3GpuPgsConstraintSolver(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, @Cast("bool") boolean usePgs) { super((Pointer)null); allocate(ctx, device, queue, usePgs); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, @Cast("bool") boolean usePgs); public native @Cast("b3Scalar") float solveGroupCacheFriendlyIterations(b3GpuGenericConstraintOCLArray gpuConstraints1, int numConstraints, @Const @ByRef b3ContactSolverInfo infoGlobal); public native @Cast("b3Scalar") float solveGroupCacheFriendlySetup(b3RigidBodyDataOCLArray gpuBodies, b3InertiaDataOCLArray gpuInertias, int numBodies, b3GpuGenericConstraintOCLArray gpuConstraints, int numConstraints, @Const @ByRef b3ContactSolverInfo infoGlobal); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java index d647770fb61..2a289915a7f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,8 +23,8 @@ public class b3GpuPgsContactSolver extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuPgsContactSolver(Pointer p) { super(p); } - public b3GpuPgsContactSolver(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, int pairCapacity) { super((Pointer)null); allocate(ctx, device, q, pairCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, int pairCapacity); + public b3GpuPgsContactSolver(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q, int pairCapacity) { super((Pointer)null); allocate(ctx, device, q, pairCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q, int pairCapacity); - public native void solveContacts(int numBodies, @ByVal cl_mem bodyBuf, @ByVal cl_mem inertiaBuf, int numContacts, @ByVal cl_mem contactBuf, @Const @ByRef b3Config config, int static0Index); + public native void solveContacts(int numBodies, @Cast("cl_mem") Pointer bodyBuf, @Cast("cl_mem") Pointer inertiaBuf, int numContacts, @Cast("cl_mem") Pointer contactBuf, @Const @ByRef b3Config config, int static0Index); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java index 4ccb4604a24..fbdffe4adb3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,8 +23,8 @@ public class b3GpuRaycast extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuRaycast(Pointer p) { super(p); } - public b3GpuRaycast(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q) { super((Pointer)null); allocate(ctx, device, q); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public b3GpuRaycast(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q) { super((Pointer)null); allocate(ctx, device, q); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); public native void castRaysHost(@Const @ByRef b3RayInfoArray raysIn, @ByRef b3RayHitArray hitResults, int numBodies, @Const b3RigidBodyData bodies, int numCollidables, @Const b3Collidable collidables, diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java index 3fa4d001d98..3e6cd55d163 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,8 +23,8 @@ public class b3GpuRigidBodyPipeline extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3GpuRigidBodyPipeline(Pointer p) { super(p); } - public b3GpuRigidBodyPipeline(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, b3GpuNarrowPhase narrowphase, b3GpuBroadphaseInterface broadphaseSap, b3DynamicBvhBroadphase broadphaseDbvt, @Const @ByRef b3Config config) { super((Pointer)null); allocate(ctx, device, q, narrowphase, broadphaseSap, broadphaseDbvt, config); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, b3GpuNarrowPhase narrowphase, b3GpuBroadphaseInterface broadphaseSap, b3DynamicBvhBroadphase broadphaseDbvt, @Const @ByRef b3Config config); + public b3GpuRigidBodyPipeline(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q, b3GpuNarrowPhase narrowphase, b3GpuBroadphaseInterface broadphaseSap, b3DynamicBvhBroadphase broadphaseDbvt, @Const @ByRef b3Config config) { super((Pointer)null); allocate(ctx, device, q, narrowphase, broadphaseSap, broadphaseDbvt, config); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q, b3GpuNarrowPhase narrowphase, b3GpuBroadphaseInterface broadphaseSap, b3DynamicBvhBroadphase broadphaseDbvt, @Const @ByRef b3Config config); public native void stepSimulation(float deltaTime); public native void integrate(float timeStep); @@ -64,7 +63,7 @@ public class b3GpuRigidBodyPipeline extends Pointer { public native void castRays(@Const @ByRef b3RayInfoArray rays, @ByRef b3RayHitArray hitResults); - public native @ByVal cl_mem getBodyBuffer(); + public native @Cast("cl_mem") Pointer getBodyBuffer(); public native int getNumBodies(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java index 046e1bac5cd..c34a734728c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -36,13 +35,13 @@ public class b3GpuRigidBodyPipelineInternalData extends Pointer { return new b3GpuRigidBodyPipelineInternalData((Pointer)this).offsetAddress(i); } - public native @ByRef cl_context m_context(); public native b3GpuRigidBodyPipelineInternalData m_context(cl_context setter); - public native @ByRef cl_device_id m_device(); public native b3GpuRigidBodyPipelineInternalData m_device(cl_device_id setter); - public native @ByRef cl_command_queue m_queue(); public native b3GpuRigidBodyPipelineInternalData m_queue(cl_command_queue setter); + public native @Cast("cl_context") Pointer m_context(); public native b3GpuRigidBodyPipelineInternalData m_context(Pointer setter); + public native @Cast("cl_device_id") Pointer m_device(); public native b3GpuRigidBodyPipelineInternalData m_device(Pointer setter); + public native @Cast("cl_command_queue") Pointer m_queue(); public native b3GpuRigidBodyPipelineInternalData m_queue(Pointer setter); - public native @ByRef cl_kernel m_integrateTransformsKernel(); public native b3GpuRigidBodyPipelineInternalData m_integrateTransformsKernel(cl_kernel setter); - public native @ByRef cl_kernel m_updateAabbsKernel(); public native b3GpuRigidBodyPipelineInternalData m_updateAabbsKernel(cl_kernel setter); - public native @ByRef cl_kernel m_clearOverlappingPairsKernel(); public native b3GpuRigidBodyPipelineInternalData m_clearOverlappingPairsKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_integrateTransformsKernel(); public native b3GpuRigidBodyPipelineInternalData m_integrateTransformsKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_updateAabbsKernel(); public native b3GpuRigidBodyPipelineInternalData m_updateAabbsKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_clearOverlappingPairsKernel(); public native b3GpuRigidBodyPipelineInternalData m_clearOverlappingPairsKernel(Pointer setter); public native b3PgsJacobiSolver m_solver(); public native b3GpuRigidBodyPipelineInternalData m_solver(b3PgsJacobiSolver setter); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java index e911386f7a6..b248eb6c95c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -58,18 +57,18 @@ public class b3GpuSapBroadphase extends b3GpuBroadphaseInterface { B3_GPU_SAP_KERNEL_BARRIER = 4, B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY = 5; - public b3GpuSapBroadphase(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, @Cast("b3GpuSapBroadphase::b3GpuSapKernelType") int kernelType/*=b3GpuSapBroadphase::B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY*/) { super((Pointer)null); allocate(ctx, device, q, kernelType); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q, @Cast("b3GpuSapBroadphase::b3GpuSapKernelType") int kernelType/*=b3GpuSapBroadphase::B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY*/); - public b3GpuSapBroadphase(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q) { super((Pointer)null); allocate(ctx, device, q); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public b3GpuSapBroadphase(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q, @Cast("b3GpuSapBroadphase::b3GpuSapKernelType") int kernelType/*=b3GpuSapBroadphase::B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY*/) { super((Pointer)null); allocate(ctx, device, q, kernelType); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q, @Cast("b3GpuSapBroadphase::b3GpuSapKernelType") int kernelType/*=b3GpuSapBroadphase::B3_GPU_SAP_KERNEL_LOCAL_SHARED_MEMORY*/); + public b3GpuSapBroadphase(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q) { super((Pointer)null); allocate(ctx, device, q); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); - public static native b3GpuBroadphaseInterface CreateFuncBruteForceCpu(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public static native b3GpuBroadphaseInterface CreateFuncBruteForceCpu(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); - public static native b3GpuBroadphaseInterface CreateFuncBruteForceGpu(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public static native b3GpuBroadphaseInterface CreateFuncBruteForceGpu(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); - public static native b3GpuBroadphaseInterface CreateFuncOriginal(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); - public static native b3GpuBroadphaseInterface CreateFuncBarrier(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); - public static native b3GpuBroadphaseInterface CreateFuncLocalMemory(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue q); + public static native b3GpuBroadphaseInterface CreateFuncOriginal(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); + public static native b3GpuBroadphaseInterface CreateFuncBarrier(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); + public static native b3GpuBroadphaseInterface CreateFuncLocalMemory(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer q); public native void calculateOverlappingPairs(int maxPairs); public native void calculateOverlappingPairsHost(int maxPairs); @@ -85,9 +84,9 @@ public class b3GpuSapBroadphase extends b3GpuBroadphaseInterface { //call writeAabbsToGpu after done making all changes (createProxy etc) public native void writeAabbsToGpu(); - public native @ByVal cl_mem getAabbBufferWS(); + public native @Cast("cl_mem") Pointer getAabbBufferWS(); public native int getNumOverlap(); - public native @ByVal cl_mem getOverlappingPairBuffer(); + public native @Cast("cl_mem") Pointer getOverlappingPairBuffer(); public native @ByRef b3Int4OCLArray getOverlappingPairsGPU(); public native @ByRef b3IntOCLArray getSmallAabbIndicesGPU(); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java index 14d29245034..8c1625335c8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java index dc001d1b5be..037a99b916d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java index ad73f7acdaf..7c5ba118258 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java index 1733031d970..f506faa6391 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java index 3736b050668..d6c8e452114 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3InertiaDataOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3InertiaDataOCLArray(Pointer p) { super(p); } - public b3InertiaDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3InertiaDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3InertiaDataOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3InertiaDataOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3InertiaDataOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3InertiaData _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3InertiaData _Val); @@ -58,8 +57,8 @@ public class b3InertiaDataOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3InertiaDataArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3InertiaDataArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java index 1bafd00fcae..29978a76345 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3Int2OCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3Int2OCLArray(Pointer p) { super(p); } - public b3Int2OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3Int2OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3Int2OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3Int2OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3Int2OCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3Int2 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3Int2 _Val); @@ -58,8 +57,8 @@ public class b3Int2OCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3Int2Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3Int2Array srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java index 401f8c89f31..0db64a4cdda 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3Int4OCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3Int4OCLArray(Pointer p) { super(p); } - public b3Int4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3Int4OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3Int4OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3Int4OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3Int4OCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3Int4 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3Int4 _Val); @@ -58,8 +57,8 @@ public class b3Int4OCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3Int4Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3Int4Array srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java index ae14ffacd71..39db1c42412 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java index d2200f3e266..aad6528d3ed 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3IntOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3IntOCLArray(Pointer p) { super(p); } - public b3IntOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3IntOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3IntOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3IntOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3IntOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(int _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(int _Val); @@ -58,8 +57,8 @@ public class b3IntOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3IntArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3IntArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java index 9e5e11c3999..72ac26cb20f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java index 9d6baf9814f..c6a44eafecd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java index 522c535004a..c42a4e15384 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -39,7 +38,7 @@ public class b3KernelArgData extends Pointer { public native int m_argIndex(); public native b3KernelArgData m_argIndex(int setter); public native int m_argSizeInBytes(); public native b3KernelArgData m_argSizeInBytes(int setter); public native int m_unusedPadding(); public native b3KernelArgData m_unusedPadding(int setter); - public native @ByRef cl_mem m_clBuffer(); public native b3KernelArgData m_clBuffer(cl_mem setter); + public native @Cast("cl_mem") Pointer m_clBuffer(); public native b3KernelArgData m_clBuffer(Pointer setter); public native @Cast("unsigned char") byte m_argData(int i); public native b3KernelArgData m_argData(int i, byte setter); @MemberGetter public native @Cast("unsigned char*") BytePointer m_argData(); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java index dee74f94dac..6d317422a9b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -26,20 +25,20 @@ public class b3LauncherCL extends Pointer { public native @ByRef b3UnsignedCharOCLArrayArray m_arrays(); public native b3LauncherCL m_arrays(b3UnsignedCharOCLArrayArray setter); - public b3LauncherCL(@ByVal cl_command_queue queue, @ByVal cl_kernel kernel, @Cast("const char*") BytePointer name) { super((Pointer)null); allocate(queue, kernel, name); } - private native void allocate(@ByVal cl_command_queue queue, @ByVal cl_kernel kernel, @Cast("const char*") BytePointer name); - public b3LauncherCL(@ByVal cl_command_queue queue, @ByVal cl_kernel kernel, String name) { super((Pointer)null); allocate(queue, kernel, name); } - private native void allocate(@ByVal cl_command_queue queue, @ByVal cl_kernel kernel, String name); + public b3LauncherCL(@Cast("cl_command_queue") Pointer queue, @Cast("cl_kernel") Pointer kernel, @Cast("const char*") BytePointer name) { super((Pointer)null); allocate(queue, kernel, name); } + private native void allocate(@Cast("cl_command_queue") Pointer queue, @Cast("cl_kernel") Pointer kernel, @Cast("const char*") BytePointer name); + public b3LauncherCL(@Cast("cl_command_queue") Pointer queue, @Cast("cl_kernel") Pointer kernel, String name) { super((Pointer)null); allocate(queue, kernel, name); } + private native void allocate(@Cast("cl_command_queue") Pointer queue, @Cast("cl_kernel") Pointer kernel, String name); - public native void setBuffer(@ByVal cl_mem clBuffer); + public native void setBuffer(@Cast("cl_mem") Pointer clBuffer); public native void setBuffers(b3BufferInfoCL buffInfo, int n); public native int getSerializationBufferSize(); - public native int deserializeArgs(@Cast("unsigned char*") BytePointer buf, int bufSize, @ByVal cl_context ctx); - public native int deserializeArgs(@Cast("unsigned char*") ByteBuffer buf, int bufSize, @ByVal cl_context ctx); - public native int deserializeArgs(@Cast("unsigned char*") byte[] buf, int bufSize, @ByVal cl_context ctx); + public native int deserializeArgs(@Cast("unsigned char*") BytePointer buf, int bufSize, @Cast("cl_context") Pointer ctx); + public native int deserializeArgs(@Cast("unsigned char*") ByteBuffer buf, int bufSize, @Cast("cl_context") Pointer ctx); + public native int deserializeArgs(@Cast("unsigned char*") byte[] buf, int bufSize, @Cast("cl_context") Pointer ctx); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java index d81797d482a..79877fe441e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java index 20ddeaa6878..d1d1c60e50e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java index b47be620923..be831e968ca 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -46,7 +45,7 @@ public class b3OpenCLDeviceInfo extends Pointer { @MemberGetter public native @Cast("char*") BytePointer m_deviceExtensions(); public native @Cast("cl_device_type") long m_deviceType(); public native b3OpenCLDeviceInfo m_deviceType(long setter); - public native @Cast("unsigned int") int m_computeUnits(); public native b3OpenCLDeviceInfo m_computeUnits(int setter); + public native @Cast("cl_uint") int m_computeUnits(); public native b3OpenCLDeviceInfo m_computeUnits(int setter); public native @Cast("size_t") long m_workitemDims(); public native b3OpenCLDeviceInfo m_workitemDims(long setter); public native @Cast("size_t") long m_workItemSize(int i); public native b3OpenCLDeviceInfo m_workItemSize(int i, long setter); @MemberGetter public native @Cast("size_t*") SizeTPointer m_workItemSize(); @@ -56,24 +55,24 @@ public class b3OpenCLDeviceInfo extends Pointer { public native @Cast("size_t") long m_image3dMaxHeight(); public native b3OpenCLDeviceInfo m_image3dMaxHeight(long setter); public native @Cast("size_t") long m_image3dMaxDepth(); public native b3OpenCLDeviceInfo m_image3dMaxDepth(long setter); public native @Cast("size_t") long m_workgroupSize(); public native b3OpenCLDeviceInfo m_workgroupSize(long setter); - public native @Cast("unsigned int") int m_clockFrequency(); public native b3OpenCLDeviceInfo m_clockFrequency(int setter); - public native @Cast("unsigned long") long m_constantBufferSize(); public native b3OpenCLDeviceInfo m_constantBufferSize(long setter); - public native @Cast("unsigned long") long m_localMemSize(); public native b3OpenCLDeviceInfo m_localMemSize(long setter); - public native @Cast("unsigned long") long m_globalMemSize(); public native b3OpenCLDeviceInfo m_globalMemSize(long setter); - public native @Cast("bool") boolean m_errorCorrectionSupport(); public native b3OpenCLDeviceInfo m_errorCorrectionSupport(boolean setter); + public native @Cast("cl_uint") int m_clockFrequency(); public native b3OpenCLDeviceInfo m_clockFrequency(int setter); + public native @Cast("cl_ulong") long m_constantBufferSize(); public native b3OpenCLDeviceInfo m_constantBufferSize(long setter); + public native @Cast("cl_ulong") long m_localMemSize(); public native b3OpenCLDeviceInfo m_localMemSize(long setter); + public native @Cast("cl_ulong") long m_globalMemSize(); public native b3OpenCLDeviceInfo m_globalMemSize(long setter); + public native @Cast("cl_bool") int m_errorCorrectionSupport(); public native b3OpenCLDeviceInfo m_errorCorrectionSupport(int setter); public native @Cast("cl_device_local_mem_type") int m_localMemType(); public native b3OpenCLDeviceInfo m_localMemType(int setter); - public native @Cast("unsigned int") int m_maxReadImageArgs(); public native b3OpenCLDeviceInfo m_maxReadImageArgs(int setter); - public native @Cast("unsigned int") int m_maxWriteImageArgs(); public native b3OpenCLDeviceInfo m_maxWriteImageArgs(int setter); + public native @Cast("cl_uint") int m_maxReadImageArgs(); public native b3OpenCLDeviceInfo m_maxReadImageArgs(int setter); + public native @Cast("cl_uint") int m_maxWriteImageArgs(); public native b3OpenCLDeviceInfo m_maxWriteImageArgs(int setter); - public native @Cast("unsigned int") int m_addressBits(); public native b3OpenCLDeviceInfo m_addressBits(int setter); - public native @Cast("unsigned long") long m_maxMemAllocSize(); public native b3OpenCLDeviceInfo m_maxMemAllocSize(long setter); + public native @Cast("cl_uint") int m_addressBits(); public native b3OpenCLDeviceInfo m_addressBits(int setter); + public native @Cast("cl_ulong") long m_maxMemAllocSize(); public native b3OpenCLDeviceInfo m_maxMemAllocSize(long setter); public native @Cast("cl_command_queue_properties") long m_queueProperties(); public native b3OpenCLDeviceInfo m_queueProperties(long setter); - public native @Cast("bool") boolean m_imageSupport(); public native b3OpenCLDeviceInfo m_imageSupport(boolean setter); - public native @Cast("unsigned int") int m_vecWidthChar(); public native b3OpenCLDeviceInfo m_vecWidthChar(int setter); - public native @Cast("unsigned int") int m_vecWidthShort(); public native b3OpenCLDeviceInfo m_vecWidthShort(int setter); - public native @Cast("unsigned int") int m_vecWidthInt(); public native b3OpenCLDeviceInfo m_vecWidthInt(int setter); - public native @Cast("unsigned int") int m_vecWidthLong(); public native b3OpenCLDeviceInfo m_vecWidthLong(int setter); - public native @Cast("unsigned int") int m_vecWidthFloat(); public native b3OpenCLDeviceInfo m_vecWidthFloat(int setter); - public native @Cast("unsigned int") int m_vecWidthDouble(); public native b3OpenCLDeviceInfo m_vecWidthDouble(int setter); + public native @Cast("cl_bool") int m_imageSupport(); public native b3OpenCLDeviceInfo m_imageSupport(int setter); + public native @Cast("cl_uint") int m_vecWidthChar(); public native b3OpenCLDeviceInfo m_vecWidthChar(int setter); + public native @Cast("cl_uint") int m_vecWidthShort(); public native b3OpenCLDeviceInfo m_vecWidthShort(int setter); + public native @Cast("cl_uint") int m_vecWidthInt(); public native b3OpenCLDeviceInfo m_vecWidthInt(int setter); + public native @Cast("cl_uint") int m_vecWidthLong(); public native b3OpenCLDeviceInfo m_vecWidthLong(int setter); + public native @Cast("cl_uint") int m_vecWidthFloat(); public native b3OpenCLDeviceInfo m_vecWidthFloat(int setter); + public native @Cast("cl_uint") int m_vecWidthDouble(); public native b3OpenCLDeviceInfo m_vecWidthDouble(int setter); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java index 56f6f45f892..a90a9286424 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java index c81cd1142f8..a01492e82ea 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -39,61 +38,61 @@ public class b3OpenCLUtils extends Pointer { /** CL Context optionally takes a GL context. This is a generic type because we don't really want this code * to have to understand GL types. It is a HGLRC in _WIN32 or a GLXContext otherwise. */ - public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); - public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, IntPointer pErrNum); - public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); - public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, IntBuffer pErrNum); - public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, cl_platform_id platformId/*=0*/); - public static native @ByVal cl_context createContextFromType(@Cast("cl_device_type") long deviceType, int[] pErrNum); + public static native @Cast("cl_context") Pointer createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, @Cast("cl_platform_id*") PointerPointer platformId/*=0*/); + public static native @Cast("cl_context") Pointer createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntPointer pErrNum); + public static native @Cast("cl_context") Pointer createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, @Cast("cl_platform_id*") PointerPointer platformId/*=0*/); + public static native @Cast("cl_context") Pointer createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntBuffer pErrNum); + public static native @Cast("cl_context") Pointer createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/, @Cast("cl_platform_id*") PointerPointer platformId/*=0*/); + public static native @Cast("cl_context") Pointer createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") int[] pErrNum); - public static native int getNumDevices(@ByVal cl_context cxMainContext); - public static native @ByVal cl_device_id getDevice(@ByVal cl_context cxMainContext, int nr); + public static native int getNumDevices(@Cast("cl_context") Pointer cxMainContext); + public static native @Cast("cl_device_id") Pointer getDevice(@Cast("cl_context") Pointer cxMainContext, int nr); - public static native void getDeviceInfo(@ByVal cl_device_id device, b3OpenCLDeviceInfo info); + public static native void getDeviceInfo(@Cast("cl_device_id") Pointer device, b3OpenCLDeviceInfo info); - public static native void printDeviceInfo(@ByVal cl_device_id device); + public static native void printDeviceInfo(@Cast("cl_device_id") Pointer device); - public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, IntPointer pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, @Cast("const char*") BytePointer additionalMacros/*=""*/); - public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName); - public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, IntBuffer pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, String additionalMacros/*=""*/); - public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName); - public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, int[] pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, @Cast("const char*") BytePointer additionalMacros/*=""*/); - public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, IntPointer pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, String additionalMacros/*=""*/); - public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, IntBuffer pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, @Cast("const char*") BytePointer additionalMacros/*=""*/); - public static native @ByVal cl_kernel compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, int[] pErrNum/*=0*/, @ByVal(nullValue = "cl_program(0)") cl_program prog, String additionalMacros/*=""*/); + public static native @Cast("cl_kernel") Pointer compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, @Cast("cl_int*") IntPointer pErrNum/*=0*/, @Cast("cl_program") Pointer prog/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/); + public static native @Cast("cl_kernel") Pointer compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName); + public static native @Cast("cl_kernel") Pointer compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, String kernelName, @Cast("cl_int*") IntBuffer pErrNum/*=0*/, @Cast("cl_program") Pointer prog/*=0*/, String additionalMacros/*=""*/); + public static native @Cast("cl_kernel") Pointer compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, String kernelName); + public static native @Cast("cl_kernel") Pointer compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, @Cast("cl_int*") int[] pErrNum/*=0*/, @Cast("cl_program") Pointer prog/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/); + public static native @Cast("cl_kernel") Pointer compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, String kernelName, @Cast("cl_int*") IntPointer pErrNum/*=0*/, @Cast("cl_program") Pointer prog/*=0*/, String additionalMacros/*=""*/); + public static native @Cast("cl_kernel") Pointer compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, @Cast("cl_int*") IntBuffer pErrNum/*=0*/, @Cast("cl_program") Pointer prog/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/); + public static native @Cast("cl_kernel") Pointer compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, String kernelName, @Cast("cl_int*") int[] pErrNum/*=0*/, @Cast("cl_program") Pointer prog/*=0*/, String additionalMacros/*=""*/); //optional - public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, IntPointer pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); - public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource); - public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, IntBuffer pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); - public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource); - public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, int[] pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); - public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, IntPointer pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); - public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, IntBuffer pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); - public static native @ByVal cl_program compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, int[] pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @Cast("cl_program") Pointer compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("cl_int*") IntPointer pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @Cast("cl_program") Pointer compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource); + public static native @Cast("cl_program") Pointer compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, @Cast("cl_int*") IntBuffer pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @Cast("cl_program") Pointer compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource); + public static native @Cast("cl_program") Pointer compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("cl_int*") int[] pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @Cast("cl_program") Pointer compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, @Cast("cl_int*") IntPointer pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @Cast("cl_program") Pointer compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("cl_int*") IntBuffer pErrNum/*=0*/, @Cast("const char*") BytePointer additionalMacros/*=""*/, @Cast("const char*") BytePointer srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); + public static native @Cast("cl_program") Pointer compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, @Cast("cl_int*") int[] pErrNum/*=0*/, String additionalMacros/*=""*/, String srcFileNameForCaching/*=0*/, @Cast("bool") boolean disableBinaryCaching/*=false*/); //the following optional APIs provide access using specific platform information - public static native int getNumPlatforms(IntPointer pErrNum/*=0*/); + public static native int getNumPlatforms(@Cast("cl_int*") IntPointer pErrNum/*=0*/); public static native int getNumPlatforms(); - public static native int getNumPlatforms(IntBuffer pErrNum/*=0*/); - public static native int getNumPlatforms(int[] pErrNum/*=0*/); + public static native int getNumPlatforms(@Cast("cl_int*") IntBuffer pErrNum/*=0*/); + public static native int getNumPlatforms(@Cast("cl_int*") int[] pErrNum/*=0*/); /**get the nr'th platform, where nr is in the range [0..getNumPlatforms) */ - public static native @ByVal cl_platform_id getPlatform(int nr, IntPointer pErrNum/*=0*/); - public static native @ByVal cl_platform_id getPlatform(int nr); - public static native @ByVal cl_platform_id getPlatform(int nr, IntBuffer pErrNum/*=0*/); - public static native @ByVal cl_platform_id getPlatform(int nr, int[] pErrNum/*=0*/); + public static native @Cast("cl_platform_id") Pointer getPlatform(int nr, @Cast("cl_int*") IntPointer pErrNum/*=0*/); + public static native @Cast("cl_platform_id") Pointer getPlatform(int nr); + public static native @Cast("cl_platform_id") Pointer getPlatform(int nr, @Cast("cl_int*") IntBuffer pErrNum/*=0*/); + public static native @Cast("cl_platform_id") Pointer getPlatform(int nr, @Cast("cl_int*") int[] pErrNum/*=0*/); - public static native void getPlatformInfo(@ByVal cl_platform_id platform, b3OpenCLPlatformInfo platformInfo); + public static native void getPlatformInfo(@Cast("cl_platform_id") Pointer platform, b3OpenCLPlatformInfo platformInfo); - public static native void printPlatformInfo(@ByVal cl_platform_id platform); + public static native void printPlatformInfo(@Cast("cl_platform_id") Pointer platform); public static native @Cast("const char*") BytePointer getSdkVendorName(); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntPointer pErrNum); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntBuffer pErrNum); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); - public static native @ByVal cl_context createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, int[] pErrNum); + public static native @Cast("cl_context") Pointer createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntPointer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @Cast("cl_context") Pointer createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntPointer pErrNum); + public static native @Cast("cl_context") Pointer createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntBuffer pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @Cast("cl_context") Pointer createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntBuffer pErrNum); + public static native @Cast("cl_context") Pointer createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") int[] pErrNum, Pointer pGLCtx/*=0*/, Pointer pGLDC/*=0*/, int preferredDeviceIndex/*=-1*/, int preferredPlatformIndex/*=-1*/); + public static native @Cast("cl_context") Pointer createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") int[] pErrNum); public static native void setCachePath(@Cast("const char*") BytePointer path); public static native void setCachePath(String path); } diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java index 6f2a46985a3..1f9d690cbfd 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java index 8df72aeaf4e..42e28493b36 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java index 1e3a5f94df3..e5513a844b9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java index 7ce25be2f04..17535adbb34 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java index 555a8443bb1..a691d9569d8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java index 67cefb905fd..a87f7902e5b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java index b8ccab65702..2bba3bd2ffe 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,10 +23,10 @@ public class b3PrefixScanFloat4CL extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3PrefixScanFloat4CL(Pointer p) { super(p); } - public b3PrefixScanFloat4CL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int size/*=0*/) { super((Pointer)null); allocate(ctx, device, queue, size); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int size/*=0*/); - public b3PrefixScanFloat4CL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, device, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + public b3PrefixScanFloat4CL(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int size/*=0*/) { super((Pointer)null); allocate(ctx, device, queue, size); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int size/*=0*/); + public b3PrefixScanFloat4CL(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, device, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue); public native void execute(@ByRef b3Vector3OCLArray src, @ByRef b3Vector3OCLArray dst, int n, b3Vector3 sum/*=0*/); public native void execute(@ByRef b3Vector3OCLArray src, @ByRef b3Vector3OCLArray dst, int n); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java index 7363df95e23..7ec03af612c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java index 08eee5adc35..4c4a9bfb7d7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java index 7e4ec2d1155..88252fc686a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java index 82ca083c3f1..7bb1187a251 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java index b0a9065287b..254bca99533 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java index 906e1bbf0f4..d4c252233f4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3QuantizedBvhNodeOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3QuantizedBvhNodeOCLArray(Pointer p) { super(p); } - public b3QuantizedBvhNodeOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3QuantizedBvhNodeOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3QuantizedBvhNodeOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3QuantizedBvhNodeOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3QuantizedBvhNodeOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3QuantizedBvhNode _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3QuantizedBvhNode _Val); @@ -58,8 +57,8 @@ public class b3QuantizedBvhNodeOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3QuantizedBvhNodeArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3QuantizedBvhNodeArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java index 84d18295cce..9d6ef8a373e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -58,10 +57,10 @@ public static class b3ConstData extends Pointer { NUM_WGS = 20 * 6; // cypress // NUM_WGS = 24*6, // cayman // NUM_WGS = 32*4, // nv - public b3RadixSort32CL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int initialCapacity/*=0*/) { super((Pointer)null); allocate(ctx, device, queue, initialCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int initialCapacity/*=0*/); - public b3RadixSort32CL(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, device, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue); + public b3RadixSort32CL(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int initialCapacity/*=0*/) { super((Pointer)null); allocate(ctx, device, queue, initialCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int initialCapacity/*=0*/); + public b3RadixSort32CL(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, device, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue); public native void execute(@ByRef b3UnsignedIntOCLArray keysIn, @ByRef b3UnsignedIntOCLArray keysOut, @ByRef b3UnsignedIntOCLArray valuesIn, @ByRef b3UnsignedIntOCLArray valuesOut, int n, int sortBits/*=32*/); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java index 60dd286539c..2ec98332e6f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3RayInfoOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3RayInfoOCLArray(Pointer p) { super(p); } - public b3RayInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3RayInfoOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3RayInfoOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3RayInfoOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3RayInfoOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3RayInfo _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3RayInfo _Val); @@ -58,8 +57,8 @@ public class b3RayInfoOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3RayInfoArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3RayInfoArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java index cf9de9a69e8..7cd35b216a3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3RigidBodyDataOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3RigidBodyDataOCLArray(Pointer p) { super(p); } - public b3RigidBodyDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3RigidBodyDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3RigidBodyDataOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3RigidBodyDataOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3RigidBodyDataOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3RigidBodyData _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3RigidBodyData _Val); @@ -58,8 +57,8 @@ public class b3RigidBodyDataOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3RigidBodyDataArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3RigidBodyDataArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java index e75c5a99b01..6ad6332d99e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java index b2813dc44f8..6f734a6de5a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java index aa57befed60..7707333529f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3SapAabbOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3SapAabbOCLArray(Pointer p) { super(p); } - public b3SapAabbOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3SapAabbOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3SapAabbOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3SapAabbOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3SapAabbOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3SapAabb _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3SapAabb _Val); @@ -58,8 +57,8 @@ public class b3SapAabbOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3SapAabbArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3SapAabbArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java index 808e8485163..8bc7b76f734 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java index 6325888b46f..a2fce1064b3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java index 9c447a210d3..14dc32dccc7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java index 9fd4d77b2e3..2aafd76c189 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,23 +23,23 @@ public class b3Solver extends b3SolverBase { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3Solver(Pointer p) { super(p); } - public native @ByRef cl_context m_context(); public native b3Solver m_context(cl_context setter); - public native @ByRef cl_device_id m_device(); public native b3Solver m_device(cl_device_id setter); - public native @ByRef cl_command_queue m_queue(); public native b3Solver m_queue(cl_command_queue setter); + public native @Cast("cl_context") Pointer m_context(); public native b3Solver m_context(Pointer setter); + public native @Cast("cl_device_id") Pointer m_device(); public native b3Solver m_device(Pointer setter); + public native @Cast("cl_command_queue") Pointer m_queue(); public native b3Solver m_queue(Pointer setter); public native b3UnsignedIntOCLArray m_numConstraints(); public native b3Solver m_numConstraints(b3UnsignedIntOCLArray setter); public native b3UnsignedIntOCLArray m_offsets(); public native b3Solver m_offsets(b3UnsignedIntOCLArray setter); public native int m_nIterations(); public native b3Solver m_nIterations(int setter); - public native @ByRef cl_kernel m_batchingKernel(); public native b3Solver m_batchingKernel(cl_kernel setter); - public native @ByRef cl_kernel m_batchingKernelNew(); public native b3Solver m_batchingKernelNew(cl_kernel setter); - public native @ByRef cl_kernel m_solveContactKernel(); public native b3Solver m_solveContactKernel(cl_kernel setter); - public native @ByRef cl_kernel m_solveFrictionKernel(); public native b3Solver m_solveFrictionKernel(cl_kernel setter); - public native @ByRef cl_kernel m_contactToConstraintKernel(); public native b3Solver m_contactToConstraintKernel(cl_kernel setter); - public native @ByRef cl_kernel m_setSortDataKernel(); public native b3Solver m_setSortDataKernel(cl_kernel setter); - public native @ByRef cl_kernel m_reorderContactKernel(); public native b3Solver m_reorderContactKernel(cl_kernel setter); - public native @ByRef cl_kernel m_copyConstraintKernel(); public native b3Solver m_copyConstraintKernel(cl_kernel setter); + public native @Cast("cl_kernel") Pointer m_batchingKernel(); public native b3Solver m_batchingKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_batchingKernelNew(); public native b3Solver m_batchingKernelNew(Pointer setter); + public native @Cast("cl_kernel") Pointer m_solveContactKernel(); public native b3Solver m_solveContactKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_solveFrictionKernel(); public native b3Solver m_solveFrictionKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_contactToConstraintKernel(); public native b3Solver m_contactToConstraintKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_setSortDataKernel(); public native b3Solver m_setSortDataKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_reorderContactKernel(); public native b3Solver m_reorderContactKernel(Pointer setter); + public native @Cast("cl_kernel") Pointer m_copyConstraintKernel(); public native b3Solver m_copyConstraintKernel(Pointer setter); public native b3RadixSort32CL m_sort32(); public native b3Solver m_sort32(b3RadixSort32CL setter); public native b3BoundSearchCL m_search(); public native b3Solver m_search(b3BoundSearchCL setter); @@ -53,8 +52,8 @@ public class b3Solver extends b3SolverBase { public static final int DYNAMIC_CONTACT_ALLOCATION_THRESHOLD = 2000000; - public b3Solver(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int pairCapacity) { super((Pointer)null); allocate(ctx, device, queue, pairCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_device_id device, @ByVal cl_command_queue queue, int pairCapacity); + public b3Solver(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int pairCapacity) { super((Pointer)null); allocate(ctx, device, queue, pairCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_device_id") Pointer device, @Cast("cl_command_queue") Pointer queue, int pairCapacity); public native void solveContactConstraint(@Const b3RigidBodyDataOCLArray bodyBuf, @Const b3InertiaDataOCLArray inertiaBuf, b3GpuConstraint4OCLArray constraint, Pointer additionalData, int n, int maxNumBatches); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java index b321fc852eb..e3f9e779305 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java index 8e6c187123a..48d1181289d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java index 02f275e7e05..46d4a9e6c02 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java index 8f5b4c4ec18..8b16c9b3afe 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3SortDataOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3SortDataOCLArray(Pointer p) { super(p); } - public b3SortDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3SortDataOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3SortDataOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3SortDataOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3SortDataOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3SortData _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3SortData _Val); @@ -58,8 +57,8 @@ public class b3SortDataOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3SortDataArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3SortDataArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java index 41cfdf5a882..1f576b7fe2c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java index 5c72af29d4d..86970b32584 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java index cb0fa7b790f..1ebf3a288fa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java index fbf76f617d8..e2163f1d81d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java index dd6673f1fef..4bf92dc2716 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java index 37639b1c783..d4c2958aa00 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java index 01d0ef745bd..277f6980ebc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3UnsignedCharOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3UnsignedCharOCLArray(Pointer p) { super(p); } - public b3UnsignedCharOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3UnsignedCharOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3UnsignedCharOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3UnsignedCharOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3UnsignedCharOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Cast("const unsigned char") byte _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Cast("const unsigned char") byte _Val); @@ -58,8 +57,8 @@ public class b3UnsignedCharOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3UnsignedCharArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3UnsignedCharArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java index efde65db0f9..4ab245c1822 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java index cab88f64f4d..cab253cc459 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3UnsignedIntOCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3UnsignedIntOCLArray(Pointer p) { super(p); } - public b3UnsignedIntOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3UnsignedIntOCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3UnsignedIntOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3UnsignedIntOCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3UnsignedIntOCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Cast("const unsigned int") int _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Cast("const unsigned int") int _Val); @@ -58,8 +57,8 @@ public class b3UnsignedIntOCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3UnsignedIntArray srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3UnsignedIntArray srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java index 583f7c4000d..cee74872fb3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java index 8810312f619..44531361f3f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; @@ -24,13 +23,13 @@ public class b3Vector3OCLArray extends Pointer { /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ public b3Vector3OCLArray(Pointer p) { super(p); } - public b3Vector3OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); - public b3Vector3OCLArray(@ByVal cl_context ctx, @ByVal cl_command_queue queue) { super((Pointer)null); allocate(ctx, queue); } - private native void allocate(@ByVal cl_context ctx, @ByVal cl_command_queue queue); + public b3Vector3OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/) { super((Pointer)null); allocate(ctx, queue, initialCapacity, allowGrowingCapacity); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue, @Cast("size_t") long initialCapacity/*=0*/, @Cast("bool") boolean allowGrowingCapacity/*=true*/); + public b3Vector3OCLArray(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue) { super((Pointer)null); allocate(ctx, queue); } + private native void allocate(@Cast("cl_context") Pointer ctx, @Cast("cl_command_queue") Pointer queue); /**this is an error-prone method with no error checking, be careful! */ - public native void setFromOpenCLBuffer(@ByVal cl_mem buffer, @Cast("size_t") long sizeInElements); + public native void setFromOpenCLBuffer(@Cast("cl_mem") Pointer buffer, @Cast("size_t") long sizeInElements); // we could enable this assignment, but need to make sure to avoid accidental deep copies // b3OpenCLArray& operator=(const b3AlignedObjectArray& src) @@ -39,7 +38,7 @@ public class b3Vector3OCLArray extends Pointer { // return *this; // } - public native @ByVal cl_mem getBufferCL(); + public native @Cast("cl_mem") Pointer getBufferCL(); public native @Cast("bool") boolean push_back(@Const @ByRef b3Vector3 _Val, @Cast("bool") boolean waitForCompletion/*=true*/); public native @Cast("bool") boolean push_back(@Const @ByRef b3Vector3 _Val); @@ -58,8 +57,8 @@ public class b3Vector3OCLArray extends Pointer { public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count, @Cast("bool") boolean copyOldContents/*=true*/); public native @Cast("bool") boolean reserve(@Cast("size_t") long _Count); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); - public native void copyToCL(@ByVal cl_mem destination, @Cast("size_t") long numElements); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements, @Cast("size_t") long firstElem/*=0*/, @Cast("size_t") long dstOffsetInElems/*=0*/); + public native void copyToCL(@Cast("cl_mem") Pointer destination, @Cast("size_t") long numElements); public native void copyFromHost(@Const @ByRef b3Vector3Array srcArray, @Cast("bool") boolean waitForCompletion/*=true*/); public native void copyFromHost(@Const @ByRef b3Vector3Array srcArray); diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java index 37dbcda2bf8..95f8cdb5356 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java @@ -13,7 +13,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/clew.java b/bullet/src/gen/java/org/bytedeco/bullet/clew.java deleted file mode 100644 index 15d39c8c2d2..00000000000 --- a/bullet/src/gen/java/org/bytedeco/bullet/clew.java +++ /dev/null @@ -1,2015 +0,0 @@ -// Targeted by JavaCPP version 1.5.8-SNAPSHOT: DO NOT EDIT THIS FILE - -package org.bytedeco.bullet; - -import java.nio.*; -import org.bytedeco.javacpp.*; -import org.bytedeco.javacpp.annotation.*; - -import static org.bytedeco.javacpp.presets.javacpp.*; - -public class clew extends org.bytedeco.bullet.presets.clew { - static { Loader.load(); } - -// Parsed from clew/clew.h - -// #ifndef CLEW_HPP_INCLUDED - -//! -// #define CLEW_HPP_INCLUDED - -////////////////////////////////////////////////////////////////////////// -// Copyright (c) 2009-2011 Organic Vectory B.V., KindDragon -// Written by George van Venrooij -// -// Distributed under the MIT License. -////////////////////////////////////////////////////////////////////////// - -/** \file clew.h - * \brief OpenCL run-time loader header - * - * This file contains a copy of the contents of CL.H and CL_PLATFORM.H from the - * official OpenCL spec. The purpose of this code is to load the OpenCL dynamic - * library at run-time and thus allow the executable to function on many - * platforms regardless of the vendor of the OpenCL driver actually installed. - * Some of the techniques used here were inspired by work done in the GLEW - * library (http://glew.sourceforge.net/) */ - -// Run-time dynamic linking functionality based on concepts used in GLEW -// #ifdef __OPENCL_CL_H -// #error cl.h included before clew.h -// #endif - -// #ifdef __OPENCL_CL_PLATFORM_H -// #error cl_platform.h included before clew.h -// #endif - -// Prevent cl.h inclusion -// #define __OPENCL_CL_H -// Prevent cl_platform.h inclusion -// #define __CL_PLATFORM_H - -/******************************************************************************* -* Copyright (c) 2008-2010 The Khronos Group Inc. -* -* Permission is hereby granted, free of charge, to any person obtaining a -* copy of this software and/or associated documentation files (the -* "Materials"), to deal in the Materials without restriction, including -* without limitation the rights to use, copy, modify, merge, publish, -* distribute, sublicense, and/or sell copies of the Materials, and to -* permit persons to whom the Materials are furnished to do so, subject to -* the following conditions: -* -* The above copyright notice and this permission notice shall be included -* in all copies or substantial portions of the Materials. -* -* THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. -* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -* MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. -******************************************************************************/ -// #ifdef __APPLE__ -/* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */ -// #include -// #endif - -// #ifdef __cplusplus -// #endif - -// #if defined(_WIN32) -// #else -// #define CL_API_ENTRY -// #define CL_API_CALL -// #define CL_CALLBACK -// #endif - //disabled the APPLE thing, don't know why it is there, is just causes tons of warnings - -// #ifdef __APPLE1__ -// #else -// #define CL_EXTENSION_WEAK_LINK -// #define CL_API_SUFFIX__VERSION_1_0 -// #define CL_EXT_SUFFIX__VERSION_1_0 -// #define CL_API_SUFFIX__VERSION_1_1 -// #define CL_EXT_SUFFIX__VERSION_1_1 -// #define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED -// #endif - -// #if (defined(_WIN32) && defined(_MSC_VER)) - -// #else - -// #include - -/* scalar types */ - -/* Macro names and corresponding values defined by OpenCL */ -public static final int CL_CHAR_BIT = 8; -public static final int CL_SCHAR_MAX = 127; -public static final int CL_SCHAR_MIN = (-127 - 1); -public static final int CL_CHAR_MAX = CL_SCHAR_MAX; -public static final int CL_CHAR_MIN = CL_SCHAR_MIN; -public static final int CL_UCHAR_MAX = 255; -public static final int CL_SHRT_MAX = 32767; -public static final int CL_SHRT_MIN = (-32767 - 1); -public static final int CL_USHRT_MAX = 65535; -public static final int CL_INT_MAX = 2147483647; -public static final int CL_INT_MIN = (-2147483647 - 1); -public static final int CL_UINT_MAX = 0xffffffff; -public static native @MemberGetter long CL_LONG_MAX(); -public static final long CL_LONG_MAX = CL_LONG_MAX(); -public static native @MemberGetter long CL_LONG_MIN(); -public static final long CL_LONG_MIN = CL_LONG_MIN(); -public static native @MemberGetter @Cast("unsigned long") long CL_ULONG_MAX(); -public static final long CL_ULONG_MAX = CL_ULONG_MAX(); - -public static final int CL_FLT_DIG = 6; -public static final int CL_FLT_MANT_DIG = 24; -public static final int CL_FLT_MAX_10_EXP = +38; -public static final int CL_FLT_MAX_EXP = +128; -public static final int CL_FLT_MIN_10_EXP = -37; -public static final int CL_FLT_MIN_EXP = -125; -public static final int CL_FLT_RADIX = 2; -public static final double CL_FLT_MAX = 0x1.fffffep127f; -public static final double CL_FLT_MIN = 0x1.0p-126f; -public static final double CL_FLT_EPSILON = 0x1.0p-23f; - -public static final int CL_DBL_DIG = 15; -public static final int CL_DBL_MANT_DIG = 53; -public static final int CL_DBL_MAX_10_EXP = +308; -public static final int CL_DBL_MAX_EXP = +1024; -public static final int CL_DBL_MIN_10_EXP = -307; -public static final int CL_DBL_MIN_EXP = -1021; -public static final int CL_DBL_RADIX = 2; -public static final double CL_DBL_MAX = 0x1.fffffffffffffp1023; -public static final double CL_DBL_MIN = 0x1.0p-1022; -public static final double CL_DBL_EPSILON = 0x1.0p-52; - -public static final double CL_M_E = 2.718281828459045090796; -public static final double CL_M_LOG2E = 1.442695040888963387005; -public static final double CL_M_LOG10E = 0.434294481903251816668; -public static final double CL_M_LN2 = 0.693147180559945286227; -public static final double CL_M_LN10 = 2.302585092994045901094; -public static final double CL_M_PI = 3.141592653589793115998; -public static final double CL_M_PI_2 = 1.570796326794896557999; -public static final double CL_M_PI_4 = 0.785398163397448278999; -public static final double CL_M_1_PI = 0.318309886183790691216; -public static final double CL_M_2_PI = 0.636619772367581382433; -public static final double CL_M_2_SQRTPI = 1.128379167095512558561; -public static final double CL_M_SQRT2 = 1.414213562373095145475; -public static final double CL_M_SQRT1_2 = 0.707106781186547572737; - -public static final double CL_M_E_F = 2.71828174591064f; -public static final double CL_M_LOG2E_F = 1.44269502162933f; -public static final double CL_M_LOG10E_F = 0.43429449200630f; -public static final double CL_M_LN2_F = 0.69314718246460f; -public static final double CL_M_LN10_F = 2.30258512496948f; -public static final double CL_M_PI_F = 3.14159274101257f; -public static final double CL_M_PI_2_F = 1.57079637050629f; -public static final double CL_M_PI_4_F = 0.78539818525314f; -public static final double CL_M_1_PI_F = 0.31830987334251f; -public static final double CL_M_2_PI_F = 0.63661974668503f; -public static final double CL_M_2_SQRTPI_F = 1.12837922573090f; -public static final double CL_M_SQRT2_F = 1.41421353816986f; -public static final double CL_M_SQRT1_2_F = 0.70710676908493f; - -// #if defined(__GNUC__) -// #else -public static final double CL_HUGE_VALF = ((float)1e50); -// #define CL_HUGE_VAL ((cl_double)1e500) - -// #define CL_NAN nanf("") -// #endif -public static final double CL_MAXFLOAT = CL_FLT_MAX; -public static final double CL_INFINITY = CL_HUGE_VALF; - -// #endif - -// #include - - /* Mirror types to GL types. Mirror types allow us to avoid deciding which headers to load based on whether we are using GL or GLES here. */ - - /* - * Vector types - * - * Note: OpenCL requires that all types be naturally aligned. - * This means that vector types must be naturally aligned. - * For example, a vector of four floats must be aligned to - * a 16 byte boundary (calculated as 4 * the natural 4-byte - * alignment of the float). The alignment qualifiers here - * will only function properly if your compiler supports them - * and if you don't actively work to defeat them. For example, - * in order for a cl_float4 to be 16 byte aligned in a struct, - * the start of the struct must itself be 16-byte aligned. - * - * Maintaining proper alignment is the user's responsibility. - */ - -// #ifdef _MSC_VER -// #if defined(_M_IX86) -// #if _M_IX86_FP >= 0 -// #define __SSE__ -// #endif -// #if _M_IX86_FP >= 1 -// #define __SSE2__ -// #endif -// #elif defined(_M_X64) -// #define __SSE__ -// #define __SSE2__ -// #endif -// #endif - -/* Define basic vector types */ -// #if defined(__VEC__) -// #endif - -// #if defined(__SSE__) -// #endif - -// #if defined(__SSE2__) -// #endif - -// #if defined(__MMX__) -// #endif - -// #if defined(__AVX__) -// #endif - -/* Define alignment keys */ -// #if defined(__GNUC__) -// #elif defined(_WIN32) && (_MSC_VER) -/* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements */ -/* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx */ -/* #include */ -/* #define CL_ALIGNED(_x) _CRT_ALIGN(_x) */ -// #define CL_ALIGNED(_x) -// #else -// #warning Need to implement some method to align data here -// #define CL_ALIGNED(_x) -// #endif - -/* Indicate whether .xyzw, .s0123 and .hi.lo are supported */ -// #if (defined(__GNUC__) && !defined(__STRICT_ANSI__)) || (defined(_MSC_VER) && !defined(__STDC__)) -/* .xyzw and .s0123...{f|F} are supported */ -public static final int CL_HAS_NAMED_VECTOR_FIELDS = 1; -/* .hi and .lo are supported */ -public static final int CL_HAS_HI_LO_VECTOR_FIELDS = 1; - -// #define CL_NAMED_STRUCT_SUPPORTED -// #endif - -// #if defined(CL_NAMED_STRUCT_SUPPORTED) && defined(_MSC_VER) -// #endif - - /* Define cl_vector types */ - - /* ---- cl_charn ---- */ - public static class cl_char2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_char2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_char2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_char2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_char2 position(long position) { - return (cl_char2)super.position(position); - } - @Override public cl_char2 getPointer(long i) { - return new cl_char2((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_char") byte s(int i); public native cl_char2 s(int i, byte setter); - @MemberGetter public native @Cast("cl_char*") BytePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_CHAR2__) -// #endif - } - - public static class cl_char4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_char4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_char4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_char4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_char4 position(long position) { - return (cl_char4)super.position(position); - } - @Override public cl_char4 getPointer(long i) { - return new cl_char4((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_char") byte s(int i); public native cl_char4 s(int i, byte setter); - @MemberGetter public native @Cast("cl_char*") BytePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_CHAR2__) -// #endif -// #if defined(__CL_CHAR4__) -// #endif - } - - /* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */ - - public static class cl_char8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_char8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_char8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_char8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_char8 position(long position) { - return (cl_char8)super.position(position); - } - @Override public cl_char8 getPointer(long i) { - return new cl_char8((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_char") byte s(int i); public native cl_char8 s(int i, byte setter); - @MemberGetter public native @Cast("cl_char*") BytePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_CHAR2__) -// #endif -// #if defined(__CL_CHAR4__) -// #endif -// #if defined(__CL_CHAR8__) -// #endif - } - - public static class cl_char16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_char16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_char16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_char16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_char16 position(long position) { - return (cl_char16)super.position(position); - } - @Override public cl_char16 getPointer(long i) { - return new cl_char16((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_char") byte s(int i); public native cl_char16 s(int i, byte setter); - @MemberGetter public native @Cast("cl_char*") BytePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_CHAR2__) -// #endif -// #if defined(__CL_CHAR4__) -// #endif -// #if defined(__CL_CHAR8__) -// #endif -// #if defined(__CL_CHAR16__) -// #endif - } - - /* ---- cl_ucharn ---- */ - public static class cl_uchar2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_uchar2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_uchar2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_uchar2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_uchar2 position(long position) { - return (cl_uchar2)super.position(position); - } - @Override public cl_uchar2 getPointer(long i) { - return new cl_uchar2((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_uchar") byte s(int i); public native cl_uchar2 s(int i, byte setter); - @MemberGetter public native @Cast("cl_uchar*") BytePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__cl_uchar2__) -// #endif - } - - public static class cl_uchar4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_uchar4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_uchar4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_uchar4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_uchar4 position(long position) { - return (cl_uchar4)super.position(position); - } - @Override public cl_uchar4 getPointer(long i) { - return new cl_uchar4((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_uchar") byte s(int i); public native cl_uchar4 s(int i, byte setter); - @MemberGetter public native @Cast("cl_uchar*") BytePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_UCHAR2__) -// #endif -// #if defined(__CL_UCHAR4__) -// #endif - } - - /* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */ - - public static class cl_uchar8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_uchar8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_uchar8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_uchar8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_uchar8 position(long position) { - return (cl_uchar8)super.position(position); - } - @Override public cl_uchar8 getPointer(long i) { - return new cl_uchar8((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_uchar") byte s(int i); public native cl_uchar8 s(int i, byte setter); - @MemberGetter public native @Cast("cl_uchar*") BytePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_UCHAR2__) -// #endif -// #if defined(__CL_UCHAR4__) -// #endif -// #if defined(__CL_UCHAR8__) -// #endif - } - - public static class cl_uchar16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_uchar16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_uchar16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_uchar16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_uchar16 position(long position) { - return (cl_uchar16)super.position(position); - } - @Override public cl_uchar16 getPointer(long i) { - return new cl_uchar16((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_uchar") byte s(int i); public native cl_uchar16 s(int i, byte setter); - @MemberGetter public native @Cast("cl_uchar*") BytePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_UCHAR2__) -// #endif -// #if defined(__CL_UCHAR4__) -// #endif -// #if defined(__CL_UCHAR8__) -// #endif -// #if defined(__CL_UCHAR16__) -// #endif - } - - /* ---- cl_shortn ---- */ - public static class cl_short2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_short2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_short2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_short2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_short2 position(long position) { - return (cl_short2)super.position(position); - } - @Override public cl_short2 getPointer(long i) { - return new cl_short2((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_short") short s(int i); public native cl_short2 s(int i, short setter); - @MemberGetter public native @Cast("cl_short*") ShortPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_SHORT2__) -// #endif - } - - public static class cl_short4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_short4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_short4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_short4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_short4 position(long position) { - return (cl_short4)super.position(position); - } - @Override public cl_short4 getPointer(long i) { - return new cl_short4((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_short") short s(int i); public native cl_short4 s(int i, short setter); - @MemberGetter public native @Cast("cl_short*") ShortPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_SHORT2__) -// #endif -// #if defined(__CL_SHORT4__) -// #endif - } - - /* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */ - - public static class cl_short8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_short8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_short8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_short8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_short8 position(long position) { - return (cl_short8)super.position(position); - } - @Override public cl_short8 getPointer(long i) { - return new cl_short8((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_short") short s(int i); public native cl_short8 s(int i, short setter); - @MemberGetter public native @Cast("cl_short*") ShortPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_SHORT2__) -// #endif -// #if defined(__CL_SHORT4__) -// #endif -// #if defined(__CL_SHORT8__) -// #endif - } - - public static class cl_short16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_short16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_short16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_short16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_short16 position(long position) { - return (cl_short16)super.position(position); - } - @Override public cl_short16 getPointer(long i) { - return new cl_short16((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_short") short s(int i); public native cl_short16 s(int i, short setter); - @MemberGetter public native @Cast("cl_short*") ShortPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_SHORT2__) -// #endif -// #if defined(__CL_SHORT4__) -// #endif -// #if defined(__CL_SHORT8__) -// #endif -// #if defined(__CL_SHORT16__) -// #endif - } - - /* ---- cl_ushortn ---- */ - public static class cl_ushort2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_ushort2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_ushort2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_ushort2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_ushort2 position(long position) { - return (cl_ushort2)super.position(position); - } - @Override public cl_ushort2 getPointer(long i) { - return new cl_ushort2((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_ushort") short s(int i); public native cl_ushort2 s(int i, short setter); - @MemberGetter public native @Cast("cl_ushort*") ShortPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_USHORT2__) -// #endif - } - - public static class cl_ushort4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_ushort4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_ushort4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_ushort4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_ushort4 position(long position) { - return (cl_ushort4)super.position(position); - } - @Override public cl_ushort4 getPointer(long i) { - return new cl_ushort4((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_ushort") short s(int i); public native cl_ushort4 s(int i, short setter); - @MemberGetter public native @Cast("cl_ushort*") ShortPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_USHORT2__) -// #endif -// #if defined(__CL_USHORT4__) -// #endif - } - - /* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */ - - public static class cl_ushort8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_ushort8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_ushort8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_ushort8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_ushort8 position(long position) { - return (cl_ushort8)super.position(position); - } - @Override public cl_ushort8 getPointer(long i) { - return new cl_ushort8((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_ushort") short s(int i); public native cl_ushort8 s(int i, short setter); - @MemberGetter public native @Cast("cl_ushort*") ShortPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_USHORT2__) -// #endif -// #if defined(__CL_USHORT4__) -// #endif -// #if defined(__CL_USHORT8__) -// #endif - } - - public static class cl_ushort16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_ushort16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_ushort16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_ushort16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_ushort16 position(long position) { - return (cl_ushort16)super.position(position); - } - @Override public cl_ushort16 getPointer(long i) { - return new cl_ushort16((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_ushort") short s(int i); public native cl_ushort16 s(int i, short setter); - @MemberGetter public native @Cast("cl_ushort*") ShortPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_USHORT2__) -// #endif -// #if defined(__CL_USHORT4__) -// #endif -// #if defined(__CL_USHORT8__) -// #endif -// #if defined(__CL_USHORT16__) -// #endif - } - - /* ---- cl_intn ---- */ - public static class cl_int2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_int2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_int2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_int2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_int2 position(long position) { - return (cl_int2)super.position(position); - } - @Override public cl_int2 getPointer(long i) { - return new cl_int2((Pointer)this).offsetAddress(i); - } - - public native int s(int i); public native cl_int2 s(int i, int setter); - @MemberGetter public native IntPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_INT2__) -// #endif - } - - public static class cl_int4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_int4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_int4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_int4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_int4 position(long position) { - return (cl_int4)super.position(position); - } - @Override public cl_int4 getPointer(long i) { - return new cl_int4((Pointer)this).offsetAddress(i); - } - - public native int s(int i); public native cl_int4 s(int i, int setter); - @MemberGetter public native IntPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_INT2__) -// #endif -// #if defined(__CL_INT4__) -// #endif - } - - /* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */ - - public static class cl_int8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_int8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_int8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_int8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_int8 position(long position) { - return (cl_int8)super.position(position); - } - @Override public cl_int8 getPointer(long i) { - return new cl_int8((Pointer)this).offsetAddress(i); - } - - public native int s(int i); public native cl_int8 s(int i, int setter); - @MemberGetter public native IntPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_INT2__) -// #endif -// #if defined(__CL_INT4__) -// #endif -// #if defined(__CL_INT8__) -// #endif - } - - public static class cl_int16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_int16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_int16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_int16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_int16 position(long position) { - return (cl_int16)super.position(position); - } - @Override public cl_int16 getPointer(long i) { - return new cl_int16((Pointer)this).offsetAddress(i); - } - - public native int s(int i); public native cl_int16 s(int i, int setter); - @MemberGetter public native IntPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_INT2__) -// #endif -// #if defined(__CL_INT4__) -// #endif -// #if defined(__CL_INT8__) -// #endif -// #if defined(__CL_INT16__) -// #endif - } - - /* ---- cl_uintn ---- */ - public static class cl_uint2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_uint2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_uint2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_uint2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_uint2 position(long position) { - return (cl_uint2)super.position(position); - } - @Override public cl_uint2 getPointer(long i) { - return new cl_uint2((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned int") int s(int i); public native cl_uint2 s(int i, int setter); - @MemberGetter public native @Cast("unsigned int*") IntPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_UINT2__) -// #endif - } - - public static class cl_uint4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_uint4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_uint4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_uint4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_uint4 position(long position) { - return (cl_uint4)super.position(position); - } - @Override public cl_uint4 getPointer(long i) { - return new cl_uint4((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned int") int s(int i); public native cl_uint4 s(int i, int setter); - @MemberGetter public native @Cast("unsigned int*") IntPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_UINT2__) -// #endif -// #if defined(__CL_UINT4__) -// #endif - } - - /* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */ - - public static class cl_uint8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_uint8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_uint8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_uint8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_uint8 position(long position) { - return (cl_uint8)super.position(position); - } - @Override public cl_uint8 getPointer(long i) { - return new cl_uint8((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned int") int s(int i); public native cl_uint8 s(int i, int setter); - @MemberGetter public native @Cast("unsigned int*") IntPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_UINT2__) -// #endif -// #if defined(__CL_UINT4__) -// #endif -// #if defined(__CL_UINT8__) -// #endif - } - - public static class cl_uint16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_uint16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_uint16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_uint16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_uint16 position(long position) { - return (cl_uint16)super.position(position); - } - @Override public cl_uint16 getPointer(long i) { - return new cl_uint16((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned int") int s(int i); public native cl_uint16 s(int i, int setter); - @MemberGetter public native @Cast("unsigned int*") IntPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_UINT2__) -// #endif -// #if defined(__CL_UINT4__) -// #endif -// #if defined(__CL_UINT8__) -// #endif -// #if defined(__CL_UINT16__) -// #endif - } - - /* ---- cl_longn ---- */ - - /* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */ - - /* ---- cl_ulongn ---- */ - public static class cl_ulong2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_ulong2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_ulong2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_ulong2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_ulong2 position(long position) { - return (cl_ulong2)super.position(position); - } - @Override public cl_ulong2 getPointer(long i) { - return new cl_ulong2((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned long") long s(int i); public native cl_ulong2 s(int i, long setter); - @MemberGetter public native @Cast("unsigned long*") CLongPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_ULONG2__) -// #endif - } - - public static class cl_ulong4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_ulong4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_ulong4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_ulong4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_ulong4 position(long position) { - return (cl_ulong4)super.position(position); - } - @Override public cl_ulong4 getPointer(long i) { - return new cl_ulong4((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned long") long s(int i); public native cl_ulong4 s(int i, long setter); - @MemberGetter public native @Cast("unsigned long*") CLongPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_ULONG2__) -// #endif -// #if defined(__CL_ULONG4__) -// #endif - } - - /* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */ - - public static class cl_ulong8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_ulong8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_ulong8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_ulong8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_ulong8 position(long position) { - return (cl_ulong8)super.position(position); - } - @Override public cl_ulong8 getPointer(long i) { - return new cl_ulong8((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned long") long s(int i); public native cl_ulong8 s(int i, long setter); - @MemberGetter public native @Cast("unsigned long*") CLongPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_ULONG2__) -// #endif -// #if defined(__CL_ULONG4__) -// #endif -// #if defined(__CL_ULONG8__) -// #endif - } - - public static class cl_ulong16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_ulong16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_ulong16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_ulong16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_ulong16 position(long position) { - return (cl_ulong16)super.position(position); - } - @Override public cl_ulong16 getPointer(long i) { - return new cl_ulong16((Pointer)this).offsetAddress(i); - } - - public native @Cast("unsigned long") long s(int i); public native cl_ulong16 s(int i, long setter); - @MemberGetter public native @Cast("unsigned long*") CLongPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_ULONG2__) -// #endif -// #if defined(__CL_ULONG4__) -// #endif -// #if defined(__CL_ULONG8__) -// #endif -// #if defined(__CL_ULONG16__) -// #endif - } - - /* --- cl_floatn ---- */ - - public static class cl_float2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_float2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_float2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_float2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_float2 position(long position) { - return (cl_float2)super.position(position); - } - @Override public cl_float2 getPointer(long i) { - return new cl_float2((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_float") float s(int i); public native cl_float2 s(int i, float setter); - @MemberGetter public native @Cast("cl_float*") FloatPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_FLOAT2__) -// #endif - } - - public static class cl_float4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_float4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_float4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_float4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_float4 position(long position) { - return (cl_float4)super.position(position); - } - @Override public cl_float4 getPointer(long i) { - return new cl_float4((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_float") float s(int i); public native cl_float4 s(int i, float setter); - @MemberGetter public native @Cast("cl_float*") FloatPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_FLOAT2__) -// #endif -// #if defined(__CL_FLOAT4__) -// #endif - } - - /* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */ - - public static class cl_float8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_float8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_float8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_float8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_float8 position(long position) { - return (cl_float8)super.position(position); - } - @Override public cl_float8 getPointer(long i) { - return new cl_float8((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_float") float s(int i); public native cl_float8 s(int i, float setter); - @MemberGetter public native @Cast("cl_float*") FloatPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_FLOAT2__) -// #endif -// #if defined(__CL_FLOAT4__) -// #endif -// #if defined(__CL_FLOAT8__) -// #endif - } - - public static class cl_float16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_float16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_float16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_float16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_float16 position(long position) { - return (cl_float16)super.position(position); - } - @Override public cl_float16 getPointer(long i) { - return new cl_float16((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_float") float s(int i); public native cl_float16 s(int i, float setter); - @MemberGetter public native @Cast("cl_float*") FloatPointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_FLOAT2__) -// #endif -// #if defined(__CL_FLOAT4__) -// #endif -// #if defined(__CL_FLOAT8__) -// #endif -// #if defined(__CL_FLOAT16__) -// #endif - } - - /* --- cl_doublen ---- */ - - public static class cl_double2 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_double2() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_double2(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_double2(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_double2 position(long position) { - return (cl_double2)super.position(position); - } - @Override public cl_double2 getPointer(long i) { - return new cl_double2((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_double") double s(int i); public native cl_double2 s(int i, double setter); - @MemberGetter public native @Cast("cl_double*") DoublePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_DOUBLE2__) -// #endif - } - - public static class cl_double4 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_double4() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_double4(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_double4(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_double4 position(long position) { - return (cl_double4)super.position(position); - } - @Override public cl_double4 getPointer(long i) { - return new cl_double4((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_double") double s(int i); public native cl_double4 s(int i, double setter); - @MemberGetter public native @Cast("cl_double*") DoublePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_DOUBLE2__) -// #endif -// #if defined(__CL_DOUBLE4__) -// #endif - } - - /* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */ - - public static class cl_double8 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_double8() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_double8(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_double8(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_double8 position(long position) { - return (cl_double8)super.position(position); - } - @Override public cl_double8 getPointer(long i) { - return new cl_double8((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_double") double s(int i); public native cl_double8 s(int i, double setter); - @MemberGetter public native @Cast("cl_double*") DoublePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_DOUBLE2__) -// #endif -// #if defined(__CL_DOUBLE4__) -// #endif -// #if defined(__CL_DOUBLE8__) -// #endif - } - - public static class cl_double16 extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_double16() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_double16(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_double16(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_double16 position(long position) { - return (cl_double16)super.position(position); - } - @Override public cl_double16 getPointer(long i) { - return new cl_double16((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_double") double s(int i); public native cl_double16 s(int i, double setter); - @MemberGetter public native @Cast("cl_double*") DoublePointer s(); -// #if defined(CL_NAMED_STRUCT_SUPPORTED) -// #endif -// #if defined(__CL_DOUBLE2__) -// #endif -// #if defined(__CL_DOUBLE4__) -// #endif -// #if defined(__CL_DOUBLE8__) -// #endif -// #if defined(__CL_DOUBLE16__) -// #endif - } - -/* Macro to facilitate debugging - * Usage: - * Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source. - * The first line ends with: CL_PROGRAM_STRING_BEGIN \" - * Each line thereafter of OpenCL C source must end with: \n\ - * The last line ends in "; - * - * Example: - * - * const char *my_program = CL_PROGRAM_STRING_BEGIN "\ - * kernel void foo( int a, float * b ) \n\ - * { \n\ - * // my comment \n\ - * *b[ get_global_id(0)] = a; \n\ - * } \n\ - * "; - * - * This should correctly set up the line, (column) and file information for your source - * string so you can do source level debugging. - */ -// #define __CL_STRINGIFY(_x) #_x -// #define _CL_STRINGIFY(_x) __CL_STRINGIFY(_x) -// #define CL_PROGRAM_STRING_DEBUG_INFO "#line " _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n" - - // CL.h contents - /******************************************************************************/ - - @Opaque public static class _cl_platform_id extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_platform_id() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_platform_id(Pointer p) { super(p); } - } - @Opaque public static class _cl_device_id extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_device_id() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_device_id(Pointer p) { super(p); } - } - @Opaque public static class _cl_context extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_context() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_context(Pointer p) { super(p); } - } - @Opaque public static class _cl_command_queue extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_command_queue() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_command_queue(Pointer p) { super(p); } - } - @Opaque public static class _cl_mem extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_mem() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_mem(Pointer p) { super(p); } - } - @Opaque public static class _cl_program extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_program() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_program(Pointer p) { super(p); } - } - @Opaque public static class _cl_kernel extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_kernel() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_kernel(Pointer p) { super(p); } - } - @Opaque public static class _cl_event extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_event() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_event(Pointer p) { super(p); } - } - @Opaque public static class _cl_sampler extends Pointer { - /** Empty constructor. Calls {@code super((Pointer)null)}. */ - public _cl_sampler() { super((Pointer)null); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public _cl_sampler(Pointer p) { super(p); } - } /* WARNING! Unlike cl_ types in cl_platform.h, cl_bool is not guaranteed to be the same size as the bool in kernels. */ - - public static class cl_image_format extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_image_format() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_image_format(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_image_format(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_image_format position(long position) { - return (cl_image_format)super.position(position); - } - @Override public cl_image_format getPointer(long i) { - return new cl_image_format((Pointer)this).offsetAddress(i); - } - - public native @Cast("cl_channel_order") int image_channel_order(); public native cl_image_format image_channel_order(int setter); - public native @Cast("cl_channel_type") int image_channel_data_type(); public native cl_image_format image_channel_data_type(int setter); - } - - public static class cl_buffer_region extends Pointer { - static { Loader.load(); } - /** Default native constructor. */ - public cl_buffer_region() { super((Pointer)null); allocate(); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public cl_buffer_region(long size) { super((Pointer)null); allocateArray(size); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public cl_buffer_region(Pointer p) { super(p); } - private native void allocate(); - private native void allocateArray(long size); - @Override public cl_buffer_region position(long position) { - return (cl_buffer_region)super.position(position); - } - @Override public cl_buffer_region getPointer(long i) { - return new cl_buffer_region((Pointer)this).offsetAddress(i); - } - - public native @Cast("size_t") long origin(); public native cl_buffer_region origin(long setter); - public native @Cast("size_t") long size(); public native cl_buffer_region size(long setter); - } - -/******************************************************************************/ - -/* Error Codes */ -public static final int CL_SUCCESS = 0; -public static final int CL_DEVICE_NOT_FOUND = -1; -public static final int CL_DEVICE_NOT_AVAILABLE = -2; -public static final int CL_COMPILER_NOT_AVAILABLE = -3; -public static final int CL_MEM_OBJECT_ALLOCATION_FAILURE = -4; -public static final int CL_OUT_OF_RESOURCES = -5; -public static final int CL_OUT_OF_HOST_MEMORY = -6; -public static final int CL_PROFILING_INFO_NOT_AVAILABLE = -7; -public static final int CL_MEM_COPY_OVERLAP = -8; -public static final int CL_IMAGE_FORMAT_MISMATCH = -9; -public static final int CL_IMAGE_FORMAT_NOT_SUPPORTED = -10; -public static final int CL_BUILD_PROGRAM_FAILURE = -11; -public static final int CL_MAP_FAILURE = -12; -public static final int CL_MISALIGNED_SUB_BUFFER_OFFSET = -13; -public static final int CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST = -14; - -public static final int CL_INVALID_VALUE = -30; -public static final int CL_INVALID_DEVICE_TYPE = -31; -public static final int CL_INVALID_PLATFORM = -32; -public static final int CL_INVALID_DEVICE = -33; -public static final int CL_INVALID_CONTEXT = -34; -public static final int CL_INVALID_QUEUE_PROPERTIES = -35; -public static final int CL_INVALID_COMMAND_QUEUE = -36; -public static final int CL_INVALID_HOST_PTR = -37; -public static final int CL_INVALID_MEM_OBJECT = -38; -public static final int CL_INVALID_IMAGE_FORMAT_DESCRIPTOR = -39; -public static final int CL_INVALID_IMAGE_SIZE = -40; -public static final int CL_INVALID_SAMPLER = -41; -public static final int CL_INVALID_BINARY = -42; -public static final int CL_INVALID_BUILD_OPTIONS = -43; -public static final int CL_INVALID_PROGRAM = -44; -public static final int CL_INVALID_PROGRAM_EXECUTABLE = -45; -public static final int CL_INVALID_KERNEL_NAME = -46; -public static final int CL_INVALID_KERNEL_DEFINITION = -47; -public static final int CL_INVALID_KERNEL = -48; -public static final int CL_INVALID_ARG_INDEX = -49; -public static final int CL_INVALID_ARG_VALUE = -50; -public static final int CL_INVALID_ARG_SIZE = -51; -public static final int CL_INVALID_KERNEL_ARGS = -52; -public static final int CL_INVALID_WORK_DIMENSION = -53; -public static final int CL_INVALID_WORK_GROUP_SIZE = -54; -public static final int CL_INVALID_WORK_ITEM_SIZE = -55; -public static final int CL_INVALID_GLOBAL_OFFSET = -56; -public static final int CL_INVALID_EVENT_WAIT_LIST = -57; -public static final int CL_INVALID_EVENT = -58; -public static final int CL_INVALID_OPERATION = -59; -public static final int CL_INVALID_GL_OBJECT = -60; -public static final int CL_INVALID_BUFFER_SIZE = -61; -public static final int CL_INVALID_MIP_LEVEL = -62; -public static final int CL_INVALID_GLOBAL_WORK_SIZE = -63; -public static final int CL_INVALID_PROPERTY = -64; - -/* OpenCL Version */ -public static final int CL_VERSION_1_0 = 1; -public static final int CL_VERSION_1_1 = 1; - -/* cl_bool */ -public static final int CL_FALSE = 0; -public static final int CL_TRUE = 1; - -/* cl_platform_info */ -public static final int CL_PLATFORM_PROFILE = 0x0900; -public static final int CL_PLATFORM_VERSION = 0x0901; -public static final int CL_PLATFORM_NAME = 0x0902; -public static final int CL_PLATFORM_VENDOR = 0x0903; -public static final int CL_PLATFORM_EXTENSIONS = 0x0904; - -/* cl_device_type - bitfield */ -public static final int CL_DEVICE_TYPE_DEFAULT = (1 << 0); -public static final int CL_DEVICE_TYPE_CPU = (1 << 1); -public static final int CL_DEVICE_TYPE_GPU = (1 << 2); -public static final int CL_DEVICE_TYPE_ACCELERATOR = (1 << 3); -public static final int CL_DEVICE_TYPE_ALL = 0xFFFFFFFF; - -/* cl_device_info */ -public static final int CL_DEVICE_TYPE = 0x1000; -public static final int CL_DEVICE_VENDOR_ID = 0x1001; -public static final int CL_DEVICE_MAX_COMPUTE_UNITS = 0x1002; -public static final int CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS = 0x1003; -public static final int CL_DEVICE_MAX_WORK_GROUP_SIZE = 0x1004; -public static final int CL_DEVICE_MAX_WORK_ITEM_SIZES = 0x1005; -public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR = 0x1006; -public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT = 0x1007; -public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT = 0x1008; -public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG = 0x1009; -public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT = 0x100A; -public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE = 0x100B; -public static final int CL_DEVICE_MAX_CLOCK_FREQUENCY = 0x100C; -public static final int CL_DEVICE_ADDRESS_BITS = 0x100D; -public static final int CL_DEVICE_MAX_READ_IMAGE_ARGS = 0x100E; -public static final int CL_DEVICE_MAX_WRITE_IMAGE_ARGS = 0x100F; -public static final int CL_DEVICE_MAX_MEM_ALLOC_SIZE = 0x1010; -public static final int CL_DEVICE_IMAGE2D_MAX_WIDTH = 0x1011; -public static final int CL_DEVICE_IMAGE2D_MAX_HEIGHT = 0x1012; -public static final int CL_DEVICE_IMAGE3D_MAX_WIDTH = 0x1013; -public static final int CL_DEVICE_IMAGE3D_MAX_HEIGHT = 0x1014; -public static final int CL_DEVICE_IMAGE3D_MAX_DEPTH = 0x1015; -public static final int CL_DEVICE_IMAGE_SUPPORT = 0x1016; -public static final int CL_DEVICE_MAX_PARAMETER_SIZE = 0x1017; -public static final int CL_DEVICE_MAX_SAMPLERS = 0x1018; -public static final int CL_DEVICE_MEM_BASE_ADDR_ALIGN = 0x1019; -public static final int CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE = 0x101A; -public static final int CL_DEVICE_SINGLE_FP_CONFIG = 0x101B; -public static final int CL_DEVICE_GLOBAL_MEM_CACHE_TYPE = 0x101C; -public static final int CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE = 0x101D; -public static final int CL_DEVICE_GLOBAL_MEM_CACHE_SIZE = 0x101E; -public static final int CL_DEVICE_GLOBAL_MEM_SIZE = 0x101F; -public static final int CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE = 0x1020; -public static final int CL_DEVICE_MAX_CONSTANT_ARGS = 0x1021; -public static final int CL_DEVICE_LOCAL_MEM_TYPE = 0x1022; -public static final int CL_DEVICE_LOCAL_MEM_SIZE = 0x1023; -public static final int CL_DEVICE_ERROR_CORRECTION_SUPPORT = 0x1024; -public static final int CL_DEVICE_PROFILING_TIMER_RESOLUTION = 0x1025; -public static final int CL_DEVICE_ENDIAN_LITTLE = 0x1026; -public static final int CL_DEVICE_AVAILABLE = 0x1027; -public static final int CL_DEVICE_COMPILER_AVAILABLE = 0x1028; -public static final int CL_DEVICE_EXECUTION_CAPABILITIES = 0x1029; -public static final int CL_DEVICE_QUEUE_PROPERTIES = 0x102A; -public static final int CL_DEVICE_NAME = 0x102B; -public static final int CL_DEVICE_VENDOR = 0x102C; -public static final int CL_DRIVER_VERSION = 0x102D; -public static final int CL_DEVICE_PROFILE = 0x102E; -public static final int CL_DEVICE_VERSION = 0x102F; -public static final int CL_DEVICE_EXTENSIONS = 0x1030; -public static final int CL_DEVICE_PLATFORM = 0x1031; -/* 0x1032 reserved for CL_DEVICE_DOUBLE_FP_CONFIG */ -/* 0x1033 reserved for CL_DEVICE_HALF_FP_CONFIG */ -public static final int CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF = 0x1034; -public static final int CL_DEVICE_HOST_UNIFIED_MEMORY = 0x1035; -public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR = 0x1036; -public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT = 0x1037; -public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_INT = 0x1038; -public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG = 0x1039; -public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT = 0x103A; -public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE = 0x103B; -public static final int CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF = 0x103C; -public static final int CL_DEVICE_OPENCL_C_VERSION = 0x103D; - -/* cl_device_fp_config - bitfield */ -public static final int CL_FP_DENORM = (1 << 0); -public static final int CL_FP_INF_NAN = (1 << 1); -public static final int CL_FP_ROUND_TO_NEAREST = (1 << 2); -public static final int CL_FP_ROUND_TO_ZERO = (1 << 3); -public static final int CL_FP_ROUND_TO_INF = (1 << 4); -public static final int CL_FP_FMA = (1 << 5); -public static final int CL_FP_SOFT_FLOAT = (1 << 6); - -/* cl_device_mem_cache_type */ -public static final int CL_NONE = 0x0; -public static final int CL_READ_ONLY_CACHE = 0x1; -public static final int CL_READ_WRITE_CACHE = 0x2; - -/* cl_device_local_mem_type */ -public static final int CL_LOCAL = 0x1; -public static final int CL_GLOBAL = 0x2; - -/* cl_device_exec_capabilities - bitfield */ -public static final int CL_EXEC_KERNEL = (1 << 0); -public static final int CL_EXEC_NATIVE_KERNEL = (1 << 1); - -/* cl_command_queue_properties - bitfield */ -public static final int CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE = (1 << 0); -public static final int CL_QUEUE_PROFILING_ENABLE = (1 << 1); - -/* cl_context_info */ -public static final int CL_CONTEXT_REFERENCE_COUNT = 0x1080; -public static final int CL_CONTEXT_DEVICES = 0x1081; -public static final int CL_CONTEXT_PROPERTIES = 0x1082; -public static final int CL_CONTEXT_NUM_DEVICES = 0x1083; - -/* cl_context_info + cl_context_properties */ -public static final int CL_CONTEXT_PLATFORM = 0x1084; - -/* cl_command_queue_info */ -public static final int CL_QUEUE_CONTEXT = 0x1090; -public static final int CL_QUEUE_DEVICE = 0x1091; -public static final int CL_QUEUE_REFERENCE_COUNT = 0x1092; -public static final int CL_QUEUE_PROPERTIES = 0x1093; - -/* cl_mem_flags - bitfield */ -public static final int CL_MEM_READ_WRITE = (1 << 0); -public static final int CL_MEM_WRITE_ONLY = (1 << 1); -public static final int CL_MEM_READ_ONLY = (1 << 2); -public static final int CL_MEM_USE_HOST_PTR = (1 << 3); -public static final int CL_MEM_ALLOC_HOST_PTR = (1 << 4); -public static final int CL_MEM_COPY_HOST_PTR = (1 << 5); - -/* cl_channel_order */ -public static final int CL_R = 0x10B0; -public static final int CL_A = 0x10B1; -public static final int CL_RG = 0x10B2; -public static final int CL_RA = 0x10B3; -public static final int CL_RGB = 0x10B4; -public static final int CL_RGBA = 0x10B5; -public static final int CL_BGRA = 0x10B6; -public static final int CL_ARGB = 0x10B7; -public static final int CL_INTENSITY = 0x10B8; -public static final int CL_LUMINANCE = 0x10B9; -public static final int CL_Rx = 0x10BA; -public static final int CL_RGx = 0x10BB; -public static final int CL_RGBx = 0x10BC; - -/* cl_channel_type */ -public static final int CL_SNORM_INT8 = 0x10D0; -public static final int CL_SNORM_INT16 = 0x10D1; -public static final int CL_UNORM_INT8 = 0x10D2; -public static final int CL_UNORM_INT16 = 0x10D3; -public static final int CL_UNORM_SHORT_565 = 0x10D4; -public static final int CL_UNORM_SHORT_555 = 0x10D5; -public static final int CL_UNORM_INT_101010 = 0x10D6; -public static final int CL_SIGNED_INT8 = 0x10D7; -public static final int CL_SIGNED_INT16 = 0x10D8; -public static final int CL_SIGNED_INT32 = 0x10D9; -public static final int CL_UNSIGNED_INT8 = 0x10DA; -public static final int CL_UNSIGNED_INT16 = 0x10DB; -public static final int CL_UNSIGNED_INT32 = 0x10DC; -public static final int CL_HALF_FLOAT = 0x10DD; -public static final int CL_FLOAT = 0x10DE; - -/* cl_mem_object_type */ -public static final int CL_MEM_OBJECT_BUFFER = 0x10F0; -public static final int CL_MEM_OBJECT_IMAGE2D = 0x10F1; -public static final int CL_MEM_OBJECT_IMAGE3D = 0x10F2; - -/* cl_mem_info */ -public static final int CL_MEM_TYPE = 0x1100; -public static final int CL_MEM_FLAGS = 0x1101; -public static final int CL_MEM_SIZE = 0x1102; -public static final int CL_MEM_HOST_PTR = 0x1103; -public static final int CL_MEM_MAP_COUNT = 0x1104; -public static final int CL_MEM_REFERENCE_COUNT = 0x1105; -public static final int CL_MEM_CONTEXT = 0x1106; -public static final int CL_MEM_ASSOCIATED_MEMOBJECT = 0x1107; -public static final int CL_MEM_OFFSET = 0x1108; - -/* cl_image_info */ -public static final int CL_IMAGE_FORMAT = 0x1110; -public static final int CL_IMAGE_ELEMENT_SIZE = 0x1111; -public static final int CL_IMAGE_ROW_PITCH = 0x1112; -public static final int CL_IMAGE_SLICE_PITCH = 0x1113; -public static final int CL_IMAGE_WIDTH = 0x1114; -public static final int CL_IMAGE_HEIGHT = 0x1115; -public static final int CL_IMAGE_DEPTH = 0x1116; - -/* cl_addressing_mode */ -public static final int CL_ADDRESS_NONE = 0x1130; -public static final int CL_ADDRESS_CLAMP_TO_EDGE = 0x1131; -public static final int CL_ADDRESS_CLAMP = 0x1132; -public static final int CL_ADDRESS_REPEAT = 0x1133; -public static final int CL_ADDRESS_MIRRORED_REPEAT = 0x1134; - -/* cl_filter_mode */ -public static final int CL_FILTER_NEAREST = 0x1140; -public static final int CL_FILTER_LINEAR = 0x1141; - -/* cl_sampler_info */ -public static final int CL_SAMPLER_REFERENCE_COUNT = 0x1150; -public static final int CL_SAMPLER_CONTEXT = 0x1151; -public static final int CL_SAMPLER_NORMALIZED_COORDS = 0x1152; -public static final int CL_SAMPLER_ADDRESSING_MODE = 0x1153; -public static final int CL_SAMPLER_FILTER_MODE = 0x1154; - -/* cl_map_flags - bitfield */ -public static final int CL_MAP_READ = (1 << 0); -public static final int CL_MAP_WRITE = (1 << 1); - -/* cl_program_info */ -public static final int CL_PROGRAM_REFERENCE_COUNT = 0x1160; -public static final int CL_PROGRAM_CONTEXT = 0x1161; -public static final int CL_PROGRAM_NUM_DEVICES = 0x1162; -public static final int CL_PROGRAM_DEVICES = 0x1163; -public static final int CL_PROGRAM_SOURCE = 0x1164; -public static final int CL_PROGRAM_BINARY_SIZES = 0x1165; -public static final int CL_PROGRAM_BINARIES = 0x1166; - -/* cl_program_build_info */ -public static final int CL_PROGRAM_BUILD_STATUS = 0x1181; -public static final int CL_PROGRAM_BUILD_OPTIONS = 0x1182; -public static final int CL_PROGRAM_BUILD_LOG = 0x1183; - -/* cl_build_status */ -public static final int CL_BUILD_SUCCESS = 0; -public static final int CL_BUILD_NONE = -1; -public static final int CL_BUILD_ERROR = -2; -public static final int CL_BUILD_IN_PROGRESS = -3; - -/* cl_kernel_info */ -public static final int CL_KERNEL_FUNCTION_NAME = 0x1190; -public static final int CL_KERNEL_NUM_ARGS = 0x1191; -public static final int CL_KERNEL_REFERENCE_COUNT = 0x1192; -public static final int CL_KERNEL_CONTEXT = 0x1193; -public static final int CL_KERNEL_PROGRAM = 0x1194; - -/* cl_kernel_work_group_info */ -public static final int CL_KERNEL_WORK_GROUP_SIZE = 0x11B0; -public static final int CL_KERNEL_COMPILE_WORK_GROUP_SIZE = 0x11B1; -public static final int CL_KERNEL_LOCAL_MEM_SIZE = 0x11B2; -public static final int CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE = 0x11B3; -public static final int CL_KERNEL_PRIVATE_MEM_SIZE = 0x11B4; - -/* cl_event_info */ -public static final int CL_EVENT_COMMAND_QUEUE = 0x11D0; -public static final int CL_EVENT_COMMAND_TYPE = 0x11D1; -public static final int CL_EVENT_REFERENCE_COUNT = 0x11D2; -public static final int CL_EVENT_COMMAND_EXECUTION_STATUS = 0x11D3; -public static final int CL_EVENT_CONTEXT = 0x11D4; - -/* cl_command_type */ -public static final int CL_COMMAND_NDRANGE_KERNEL = 0x11F0; -public static final int CL_COMMAND_TASK = 0x11F1; -public static final int CL_COMMAND_NATIVE_KERNEL = 0x11F2; -public static final int CL_COMMAND_READ_BUFFER = 0x11F3; -public static final int CL_COMMAND_WRITE_BUFFER = 0x11F4; -public static final int CL_COMMAND_COPY_BUFFER = 0x11F5; -public static final int CL_COMMAND_READ_IMAGE = 0x11F6; -public static final int CL_COMMAND_WRITE_IMAGE = 0x11F7; -public static final int CL_COMMAND_COPY_IMAGE = 0x11F8; -public static final int CL_COMMAND_COPY_IMAGE_TO_BUFFER = 0x11F9; -public static final int CL_COMMAND_COPY_BUFFER_TO_IMAGE = 0x11FA; -public static final int CL_COMMAND_MAP_BUFFER = 0x11FB; -public static final int CL_COMMAND_MAP_IMAGE = 0x11FC; -public static final int CL_COMMAND_UNMAP_MEM_OBJECT = 0x11FD; -public static final int CL_COMMAND_MARKER = 0x11FE; -public static final int CL_COMMAND_ACQUIRE_GL_OBJECTS = 0x11FF; -public static final int CL_COMMAND_RELEASE_GL_OBJECTS = 0x1200; -public static final int CL_COMMAND_READ_BUFFER_RECT = 0x1201; -public static final int CL_COMMAND_WRITE_BUFFER_RECT = 0x1202; -public static final int CL_COMMAND_COPY_BUFFER_RECT = 0x1203; -public static final int CL_COMMAND_USER = 0x1204; - -/* command execution status */ -public static final int CL_COMPLETE = 0x0; -public static final int CL_RUNNING = 0x1; -public static final int CL_SUBMITTED = 0x2; -public static final int CL_QUEUED = 0x3; - -/* cl_buffer_create_type */ -public static final int CL_BUFFER_CREATE_TYPE_REGION = 0x1220; - -/* cl_profiling_info */ -public static final int CL_PROFILING_COMMAND_QUEUED = 0x1280; -public static final int CL_PROFILING_COMMAND_SUBMIT = 0x1281; -public static final int CL_PROFILING_COMMAND_START = 0x1282; -public static final int CL_PROFILING_COMMAND_END = 0x1283; - - /********************************************************************************************************/ - - /********************************************************************************************************/ - - /* Function signature typedef's */ - - /* Platform API */ - -/** Success error code */ -public static final int CLEW_SUCCESS = 0; -/** Error code for failing to open the dynamic library */ -public static final int CLEW_ERROR_OPEN_FAILED = -1; -/** Error code for failing to queue the closing of the dynamic library to atexit() */ -public static final int CLEW_ERROR_ATEXIT_FAILED = -2; - - /** \brief Load OpenCL dynamic library and set function entry points */ - public static native int clewInit(@Cast("const char*") BytePointer arg0); - public static native int clewInit(String arg0); - - /** \brief Exit clew and unload OpenCL dynamic library */ - public static native void clewExit(); - - /** \brief Convert an OpenCL error code to its string equivalent */ - public static native @Cast("const char*") BytePointer clewErrorString(int error); - -// #ifdef __cplusplus -// #endif - -// #endif // CLEW_HPP_INCLUDED - - -// Parsed from clew_stubs.h - -/* - * Copyright (C) 2022 Andrey Krainyak - * - * Licensed either under the Apache License, Version 2.0, or (at your option) - * under the terms of the GNU General Public License as published by - * the Free Software Foundation (subject to the "Classpath" exception), - * either version 2, or any later version (collectively, the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * http://www.gnu.org/licenses/ - * http://www.gnu.org/software/classpath/license.html - * - * or as provided in the LICENSE.txt file that accompanied this code. - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - - -// This #ifdef disables these stubs during native code compilation, -// as the stubs should be used for generation of the Java-side -// code only, and the native code should use the original definitions -// provided by clew's header. -// #ifdef XXXXXXXXXX - -public static class BuildProgramCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public BuildProgramCallback(Pointer p) { super(p); } - protected BuildProgramCallback() { allocate(); } - private native void allocate(); - public native void call(@ByVal cl_program arg0, Pointer arg1); -} -public static native int clBuildProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const char*") BytePointer arg3, BuildProgramCallback arg4, Pointer arg5); -public static native int clBuildProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, String arg3, BuildProgramCallback arg4, Pointer arg5); - -public static class CreateContextCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public CreateContextCallback(Pointer p) { super(p); } - protected CreateContextCallback() { allocate(); } - private native void allocate(); - public native void call(@Cast("const char*") BytePointer arg0, @Const Pointer arg1, @Cast("size_t") long arg2, Pointer arg3); -} -public static native @ByVal cl_context clCreateContext(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, CreateContextCallback arg3, Pointer arg4, IntPointer arg5); -public static native @ByVal cl_context clCreateContext(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, CreateContextCallback arg3, Pointer arg4, IntBuffer arg5); -public static native @ByVal cl_context clCreateContext(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, CreateContextCallback arg3, Pointer arg4, int[] arg5); -public static native @ByVal cl_context clCreateContextFromType(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("cl_device_type") long arg1, CreateContextCallback arg2, Pointer arg3, IntPointer arg4); -public static native @ByVal cl_context clCreateContextFromType(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("cl_device_type") long arg1, CreateContextCallback arg2, Pointer arg3, IntBuffer arg4); -public static native @ByVal cl_context clCreateContextFromType(@Cast("const cl_context_properties*") SizeTPointer arg0, @Cast("cl_device_type") long arg1, CreateContextCallback arg2, Pointer arg3, int[] arg4); - -public static class EnqueueNativeKernelCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public EnqueueNativeKernelCallback(Pointer p) { super(p); } - protected EnqueueNativeKernelCallback() { allocate(); } - private native void allocate(); - public native void call(Pointer arg0); -} -public static native int clEnqueueNativeKernel(@ByVal cl_command_queue arg0, EnqueueNativeKernelCallback arg1, Pointer arg2, @Cast("size_t") long arg3, @Cast("unsigned int") int arg4, @Const cl_mem arg5, @Cast("const void**") PointerPointer arg6, @Cast("unsigned int") int arg7, @Const cl_event arg8, cl_event arg9); -public static native int clEnqueueNativeKernel(@ByVal cl_command_queue arg0, EnqueueNativeKernelCallback arg1, Pointer arg2, @Cast("size_t") long arg3, @Cast("unsigned int") int arg4, @Const cl_mem arg5, @Cast("const void**") @ByPtrPtr Pointer arg6, @Cast("unsigned int") int arg7, @Const cl_event arg8, cl_event arg9); - -public static class EventCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public EventCallback(Pointer p) { super(p); } - protected EventCallback() { allocate(); } - private native void allocate(); - public native void call(@ByVal cl_event arg0, int arg1, Pointer arg2); -} -public static native int clSetEventCallback(@ByVal cl_event arg0, int arg1, EventCallback arg2, Pointer arg3); - -public static class MemObjectDestructorCallback extends FunctionPointer { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public MemObjectDestructorCallback(Pointer p) { super(p); } - protected MemObjectDestructorCallback() { allocate(); } - private native void allocate(); - public native void call(@ByVal cl_mem arg0, Pointer arg1); -} -public static native int clSetMemObjectDestructorCallback(@ByVal cl_mem arg0, MemObjectDestructorCallback arg1, Pointer arg2); - -/*************************************************************************** - Generated with bullet/gen-clew-stubs script -***************************************************************************/ - -public static native @ByVal cl_mem clCreateBuffer(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("size_t") long arg2, Pointer arg3, IntPointer arg4); -public static native @ByVal cl_mem clCreateBuffer(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("size_t") long arg2, Pointer arg3, IntBuffer arg4); -public static native @ByVal cl_mem clCreateBuffer(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("size_t") long arg2, Pointer arg3, int[] arg4); -public static native @ByVal cl_command_queue clCreateCommandQueue(@ByVal cl_context arg0, @ByVal cl_device_id arg1, @Cast("cl_command_queue_properties") long arg2, IntPointer arg3); -public static native @ByVal cl_command_queue clCreateCommandQueue(@ByVal cl_context arg0, @ByVal cl_device_id arg1, @Cast("cl_command_queue_properties") long arg2, IntBuffer arg3); -public static native @ByVal cl_command_queue clCreateCommandQueue(@ByVal cl_context arg0, @ByVal cl_device_id arg1, @Cast("cl_command_queue_properties") long arg2, int[] arg3); -public static native @ByVal cl_mem clCreateImage2D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, Pointer arg6, IntPointer arg7); -public static native @ByVal cl_mem clCreateImage2D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, Pointer arg6, IntBuffer arg7); -public static native @ByVal cl_mem clCreateImage2D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, Pointer arg6, int[] arg7); -public static native @ByVal cl_mem clCreateImage3D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, Pointer arg8, IntPointer arg9); -public static native @ByVal cl_mem clCreateImage3D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, Pointer arg8, IntBuffer arg9); -public static native @ByVal cl_mem clCreateImage3D(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Const cl_image_format arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, Pointer arg8, int[] arg9); -public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, @Cast("const char*") BytePointer arg1, IntPointer arg2); -public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, String arg1, IntBuffer arg2); -public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, @Cast("const char*") BytePointer arg1, int[] arg2); -public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, String arg1, IntPointer arg2); -public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, @Cast("const char*") BytePointer arg1, IntBuffer arg2); -public static native @ByVal cl_kernel clCreateKernel(@ByVal cl_program arg0, String arg1, int[] arg2); -public static native int clCreateKernelsInProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, cl_kernel arg2, @Cast("unsigned int*") IntPointer arg3); -public static native int clCreateKernelsInProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, cl_kernel arg2, @Cast("unsigned int*") IntBuffer arg3); -public static native int clCreateKernelsInProgram(@ByVal cl_program arg0, @Cast("unsigned int") int arg1, cl_kernel arg2, @Cast("unsigned int*") int[] arg3); -public static native @ByVal cl_program clCreateProgramWithBinary(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const unsigned char**") PointerPointer arg4, IntPointer arg5, IntPointer arg6); -public static native @ByVal cl_program clCreateProgramWithBinary(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const unsigned char**") @ByPtrPtr BytePointer arg4, IntPointer arg5, IntPointer arg6); -public static native @ByVal cl_program clCreateProgramWithBinary(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const unsigned char**") @ByPtrPtr ByteBuffer arg4, IntBuffer arg5, IntBuffer arg6); -public static native @ByVal cl_program clCreateProgramWithBinary(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Const cl_device_id arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const unsigned char**") @ByPtrPtr byte[] arg4, int[] arg5, int[] arg6); -public static native @ByVal cl_program clCreateProgramWithSource(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Cast("const char**") PointerPointer arg2, @Cast("const size_t*") SizeTPointer arg3, IntPointer arg4); -public static native @ByVal cl_program clCreateProgramWithSource(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Cast("const char**") @ByPtrPtr BytePointer arg2, @Cast("const size_t*") SizeTPointer arg3, IntPointer arg4); -public static native @ByVal cl_program clCreateProgramWithSource(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Cast("const char**") @ByPtrPtr ByteBuffer arg2, @Cast("const size_t*") SizeTPointer arg3, IntBuffer arg4); -public static native @ByVal cl_program clCreateProgramWithSource(@ByVal cl_context arg0, @Cast("unsigned int") int arg1, @Cast("const char**") @ByPtrPtr byte[] arg2, @Cast("const size_t*") SizeTPointer arg3, int[] arg4); -public static native @ByVal cl_sampler clCreateSampler(@ByVal cl_context arg0, @Cast("bool") boolean arg1, @Cast("cl_addressing_mode") int arg2, @Cast("cl_filter_mode") int arg3, IntPointer arg4); -public static native @ByVal cl_sampler clCreateSampler(@ByVal cl_context arg0, @Cast("bool") boolean arg1, @Cast("cl_addressing_mode") int arg2, @Cast("cl_filter_mode") int arg3, IntBuffer arg4); -public static native @ByVal cl_sampler clCreateSampler(@ByVal cl_context arg0, @Cast("bool") boolean arg1, @Cast("cl_addressing_mode") int arg2, @Cast("cl_filter_mode") int arg3, int[] arg4); -public static native @ByVal cl_mem clCreateSubBuffer(@ByVal cl_mem arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_buffer_create_type") int arg2, @Const Pointer arg3, IntPointer arg4); -public static native @ByVal cl_mem clCreateSubBuffer(@ByVal cl_mem arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_buffer_create_type") int arg2, @Const Pointer arg3, IntBuffer arg4); -public static native @ByVal cl_mem clCreateSubBuffer(@ByVal cl_mem arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_buffer_create_type") int arg2, @Const Pointer arg3, int[] arg4); -public static native @ByVal cl_event clCreateUserEvent(@ByVal cl_context arg0, IntPointer arg1); -public static native @ByVal cl_event clCreateUserEvent(@ByVal cl_context arg0, IntBuffer arg1); -public static native @ByVal cl_event clCreateUserEvent(@ByVal cl_context arg0, int[] arg1); -public static native int clEnqueueBarrier(@ByVal cl_command_queue arg0); -public static native int clEnqueueCopyBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); -public static native int clEnqueueCopyBufferRect(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, @Cast("size_t") long arg8, @Cast("size_t") long arg9, @Cast("unsigned int") int arg10, @Const cl_event arg11, cl_event arg12); -public static native int clEnqueueCopyBufferToImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("size_t") long arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); -public static native int clEnqueueCopyImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); -public static native int clEnqueueCopyImageToBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @ByVal cl_mem arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); -public static native void clEnqueueMapBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8, IntPointer arg9); -public static native void clEnqueueMapBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8, IntBuffer arg9); -public static native void clEnqueueMapBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("size_t") long arg4, @Cast("size_t") long arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8, int[] arg9); -public static native void clEnqueueMapImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t*") SizeTPointer arg6, @Cast("size_t*") SizeTPointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10, IntPointer arg11); -public static native void clEnqueueMapImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t*") SizeTPointer arg6, @Cast("size_t*") SizeTPointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10, IntBuffer arg11); -public static native void clEnqueueMapImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("cl_map_flags") long arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t*") SizeTPointer arg6, @Cast("size_t*") SizeTPointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10, int[] arg11); -public static native int clEnqueueMarker(@ByVal cl_command_queue arg0, cl_event arg1); -public static native int clEnqueueNDRangeKernel(@ByVal cl_command_queue arg0, @ByVal cl_kernel arg1, @Cast("unsigned int") int arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); -public static native int clEnqueueReadBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, Pointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); -public static native int clEnqueueReadBufferRect(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, @Cast("size_t") long arg8, @Cast("size_t") long arg9, Pointer arg10, @Cast("unsigned int") int arg11, @Const cl_event arg12, cl_event arg13); -public static native int clEnqueueReadImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, Pointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10); -public static native int clEnqueueTask(@ByVal cl_command_queue arg0, @ByVal cl_kernel arg1, @Cast("unsigned int") int arg2, @Const cl_event arg3, cl_event arg4); -public static native int clEnqueueUnmapMemObject(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, Pointer arg2, @Cast("unsigned int") int arg3, @Const cl_event arg4, cl_event arg5); -public static native int clEnqueueWaitForEvents(@ByVal cl_command_queue arg0, @Cast("unsigned int") int arg1, @Const cl_event arg2); -public static native int clEnqueueWriteBuffer(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("size_t") long arg3, @Cast("size_t") long arg4, @Const Pointer arg5, @Cast("unsigned int") int arg6, @Const cl_event arg7, cl_event arg8); -public static native int clEnqueueWriteBufferRect(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("const size_t*") SizeTPointer arg5, @Cast("size_t") long arg6, @Cast("size_t") long arg7, @Cast("size_t") long arg8, @Cast("size_t") long arg9, @Const Pointer arg10, @Cast("unsigned int") int arg11, @Const cl_event arg12, cl_event arg13); -public static native int clEnqueueWriteImage(@ByVal cl_command_queue arg0, @ByVal cl_mem arg1, @Cast("bool") boolean arg2, @Cast("const size_t*") SizeTPointer arg3, @Cast("const size_t*") SizeTPointer arg4, @Cast("size_t") long arg5, @Cast("size_t") long arg6, @Const Pointer arg7, @Cast("unsigned int") int arg8, @Const cl_event arg9, cl_event arg10); -public static native int clFinish(@ByVal cl_command_queue arg0); -public static native int clFlush(@ByVal cl_command_queue arg0); -public static native int clGetCommandQueueInfo(@ByVal cl_command_queue arg0, @Cast("cl_command_queue_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetContextInfo(@ByVal cl_context arg0, @Cast("cl_context_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetDeviceIDs(@ByVal cl_platform_id arg0, @Cast("cl_device_type") long arg1, @Cast("unsigned int") int arg2, cl_device_id arg3, @Cast("unsigned int*") IntPointer arg4); -public static native int clGetDeviceIDs(@ByVal cl_platform_id arg0, @Cast("cl_device_type") long arg1, @Cast("unsigned int") int arg2, cl_device_id arg3, @Cast("unsigned int*") IntBuffer arg4); -public static native int clGetDeviceIDs(@ByVal cl_platform_id arg0, @Cast("cl_device_type") long arg1, @Cast("unsigned int") int arg2, cl_device_id arg3, @Cast("unsigned int*") int[] arg4); -public static native int clGetDeviceInfo(@ByVal cl_device_id arg0, @Cast("cl_device_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetEventInfo(@ByVal cl_event arg0, @Cast("cl_event_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetEventProfilingInfo(@ByVal cl_event arg0, @Cast("cl_profiling_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native void clGetExtensionFunctionAddress(@Cast("const char*") BytePointer arg0); -public static native void clGetExtensionFunctionAddress(String arg0); -public static native int clGetImageInfo(@ByVal cl_mem arg0, @Cast("cl_image_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetKernelInfo(@ByVal cl_kernel arg0, @Cast("cl_kernel_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetKernelWorkGroupInfo(@ByVal cl_kernel arg0, @ByVal cl_device_id arg1, @Cast("cl_kernel_work_group_info") int arg2, @Cast("size_t") long arg3, Pointer arg4, @Cast("size_t*") SizeTPointer arg5); -public static native int clGetMemObjectInfo(@ByVal cl_mem arg0, @Cast("cl_mem_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetPlatformIDs(@Cast("unsigned int") int arg0, cl_platform_id arg1, @Cast("unsigned int*") IntPointer arg2); -public static native int clGetPlatformIDs(@Cast("unsigned int") int arg0, cl_platform_id arg1, @Cast("unsigned int*") IntBuffer arg2); -public static native int clGetPlatformIDs(@Cast("unsigned int") int arg0, cl_platform_id arg1, @Cast("unsigned int*") int[] arg2); -public static native int clGetPlatformInfo(@ByVal cl_platform_id arg0, @Cast("cl_platform_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetProgramBuildInfo(@ByVal cl_program arg0, @ByVal cl_device_id arg1, @Cast("cl_program_build_info") int arg2, @Cast("size_t") long arg3, Pointer arg4, @Cast("size_t*") SizeTPointer arg5); -public static native int clGetProgramInfo(@ByVal cl_program arg0, @Cast("cl_program_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetSamplerInfo(@ByVal cl_sampler arg0, @Cast("cl_sampler_info") int arg1, @Cast("size_t") long arg2, Pointer arg3, @Cast("size_t*") SizeTPointer arg4); -public static native int clGetSupportedImageFormats(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_mem_object_type") int arg2, @Cast("unsigned int") int arg3, cl_image_format arg4, @Cast("unsigned int*") IntPointer arg5); -public static native int clGetSupportedImageFormats(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_mem_object_type") int arg2, @Cast("unsigned int") int arg3, cl_image_format arg4, @Cast("unsigned int*") IntBuffer arg5); -public static native int clGetSupportedImageFormats(@ByVal cl_context arg0, @Cast("cl_mem_flags") long arg1, @Cast("cl_mem_object_type") int arg2, @Cast("unsigned int") int arg3, cl_image_format arg4, @Cast("unsigned int*") int[] arg5); -public static native int clReleaseCommandQueue(@ByVal cl_command_queue arg0); -public static native int clReleaseContext(@ByVal cl_context arg0); -public static native int clReleaseEvent(@ByVal cl_event arg0); -public static native int clReleaseKernel(@ByVal cl_kernel arg0); -public static native int clReleaseMemObject(@ByVal cl_mem arg0); -public static native int clReleaseProgram(@ByVal cl_program arg0); -public static native int clReleaseSampler(@ByVal cl_sampler arg0); -public static native int clRetainCommandQueue(@ByVal cl_command_queue arg0); -public static native int clRetainContext(@ByVal cl_context arg0); -public static native int clRetainEvent(@ByVal cl_event arg0); -public static native int clRetainKernel(@ByVal cl_kernel arg0); -public static native int clRetainMemObject(@ByVal cl_mem arg0); -public static native int clRetainProgram(@ByVal cl_program arg0); -public static native int clRetainSampler(@ByVal cl_sampler arg0); -// cl_int clSetCommandQueueProperty(cl_command_queue /* command_queue */, cl_command_queue_properties /* properties */, cl_bool /* enable */, cl_command_queue_properties * /* old_properties */); -public static native int clSetKernelArg(@ByVal cl_kernel arg0, @Cast("unsigned int") int arg1, @Cast("size_t") long arg2, @Const Pointer arg3); -public static native int clSetUserEventStatus(@ByVal cl_event arg0, int arg1); -public static native int clUnloadCompiler(); -public static native int clWaitForEvents(@Cast("unsigned int") int arg0, @Const cl_event arg1); - -// #endif // XXXXXXXXXX - - -} diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java index c40a7642478..c08c3f5cc38 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java @@ -15,7 +15,6 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; -import static org.bytedeco.bullet.clew.*; public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL { static { Loader.load(); } @@ -138,42 +137,42 @@ public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL {

* CL Context optionally takes a GL context. This is a generic type because we don't really want this code * to have to understand GL types. It is a HGLRC in _WIN32 or a GLXContext otherwise. */ - public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, cl_platform_id platformId); + public static native @Cast("cl_context") Pointer b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, @Cast("cl_platform_id*") PointerPointer platformId); + public static native @Cast("cl_context") Pointer b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, @Cast("cl_platform_id*") PointerPointer platformId); + public static native @Cast("cl_context") Pointer b3OpenCLUtils_createContextFromType(@Cast("cl_device_type") long deviceType, @Cast("cl_int*") int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex, @Cast("cl_platform_id*") PointerPointer platformId); - public static native int b3OpenCLUtils_getNumDevices(@ByVal cl_context cxMainContext); + public static native int b3OpenCLUtils_getNumDevices(@Cast("cl_context") Pointer cxMainContext); - public static native @ByVal cl_device_id b3OpenCLUtils_getDevice(@ByVal cl_context cxMainContext, int nr); + public static native @Cast("cl_device_id") Pointer b3OpenCLUtils_getDevice(@Cast("cl_context") Pointer cxMainContext, int nr); - public static native void b3OpenCLUtils_printDeviceInfo(@ByVal cl_device_id device); + public static native void b3OpenCLUtils_printDeviceInfo(@Cast("cl_device_id") Pointer device); - public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, IntPointer pErrNum, @ByVal cl_program prog, @Cast("const char*") BytePointer additionalMacros); - public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, IntBuffer pErrNum, @ByVal cl_program prog, String additionalMacros); - public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, int[] pErrNum, @ByVal cl_program prog, @Cast("const char*") BytePointer additionalMacros); - public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, IntPointer pErrNum, @ByVal cl_program prog, String additionalMacros); - public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, IntBuffer pErrNum, @ByVal cl_program prog, @Cast("const char*") BytePointer additionalMacros); - public static native @ByVal cl_kernel b3OpenCLUtils_compileCLKernelFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, String kernelName, int[] pErrNum, @ByVal cl_program prog, String additionalMacros); + public static native @Cast("cl_kernel") Pointer b3OpenCLUtils_compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, @Cast("cl_int*") IntPointer pErrNum, @Cast("cl_program") Pointer prog, @Cast("const char*") BytePointer additionalMacros); + public static native @Cast("cl_kernel") Pointer b3OpenCLUtils_compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, String kernelName, @Cast("cl_int*") IntBuffer pErrNum, @Cast("cl_program") Pointer prog, String additionalMacros); + public static native @Cast("cl_kernel") Pointer b3OpenCLUtils_compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, @Cast("cl_int*") int[] pErrNum, @Cast("cl_program") Pointer prog, @Cast("const char*") BytePointer additionalMacros); + public static native @Cast("cl_kernel") Pointer b3OpenCLUtils_compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, String kernelName, @Cast("cl_int*") IntPointer pErrNum, @Cast("cl_program") Pointer prog, String additionalMacros); + public static native @Cast("cl_kernel") Pointer b3OpenCLUtils_compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("const char*") BytePointer kernelName, @Cast("cl_int*") IntBuffer pErrNum, @Cast("cl_program") Pointer prog, @Cast("const char*") BytePointer additionalMacros); + public static native @Cast("cl_kernel") Pointer b3OpenCLUtils_compileCLKernelFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, String kernelName, @Cast("cl_int*") int[] pErrNum, @Cast("cl_program") Pointer prog, String additionalMacros); //optional - public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, IntPointer pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); - public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, IntBuffer pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); - public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, int[] pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); - public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, IntPointer pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); - public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, @Cast("const char*") BytePointer kernelSource, IntBuffer pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); - public static native @ByVal cl_program b3OpenCLUtils_compileCLProgramFromString(@ByVal cl_context clContext, @ByVal cl_device_id device, String kernelSource, int[] pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @Cast("cl_program") Pointer b3OpenCLUtils_compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("cl_int*") IntPointer pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @Cast("cl_program") Pointer b3OpenCLUtils_compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, @Cast("cl_int*") IntBuffer pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @Cast("cl_program") Pointer b3OpenCLUtils_compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("cl_int*") int[] pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @Cast("cl_program") Pointer b3OpenCLUtils_compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, @Cast("cl_int*") IntPointer pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @Cast("cl_program") Pointer b3OpenCLUtils_compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, @Cast("const char*") BytePointer kernelSource, @Cast("cl_int*") IntBuffer pErrNum, @Cast("const char*") BytePointer additionalMacros, @Cast("const char*") BytePointer srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); + public static native @Cast("cl_program") Pointer b3OpenCLUtils_compileCLProgramFromString(@Cast("cl_context") Pointer clContext, @Cast("cl_device_id") Pointer device, String kernelSource, @Cast("cl_int*") int[] pErrNum, String additionalMacros, String srcFileNameForCaching, @Cast("bool") boolean disableBinaryCaching); //the following optional APIs provide access using specific platform information - public static native int b3OpenCLUtils_getNumPlatforms(IntPointer pErrNum); - public static native int b3OpenCLUtils_getNumPlatforms(IntBuffer pErrNum); - public static native int b3OpenCLUtils_getNumPlatforms(int[] pErrNum); + public static native int b3OpenCLUtils_getNumPlatforms(@Cast("cl_int*") IntPointer pErrNum); + public static native int b3OpenCLUtils_getNumPlatforms(@Cast("cl_int*") IntBuffer pErrNum); + public static native int b3OpenCLUtils_getNumPlatforms(@Cast("cl_int*") int[] pErrNum); /**get the nr'th platform, where nr is in the range [0..getNumPlatforms) */ - public static native @ByVal cl_platform_id b3OpenCLUtils_getPlatform(int nr, IntPointer pErrNum); - public static native @ByVal cl_platform_id b3OpenCLUtils_getPlatform(int nr, IntBuffer pErrNum); - public static native @ByVal cl_platform_id b3OpenCLUtils_getPlatform(int nr, int[] pErrNum); + public static native @Cast("cl_platform_id") Pointer b3OpenCLUtils_getPlatform(int nr, @Cast("cl_int*") IntPointer pErrNum); + public static native @Cast("cl_platform_id") Pointer b3OpenCLUtils_getPlatform(int nr, @Cast("cl_int*") IntBuffer pErrNum); + public static native @Cast("cl_platform_id") Pointer b3OpenCLUtils_getPlatform(int nr, @Cast("cl_int*") int[] pErrNum); - public static native void b3OpenCLUtils_printPlatformInfo(@ByVal cl_platform_id platform); + public static native void b3OpenCLUtils_printPlatformInfo(@Cast("cl_platform_id") Pointer platform); public static native @Cast("const char*") BytePointer b3OpenCLUtils_getSdkVendorName(); @@ -181,9 +180,9 @@ public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL { public static native void b3OpenCLUtils_setCachePath(@Cast("const char*") BytePointer path); public static native void b3OpenCLUtils_setCachePath(String path); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); - public static native @ByVal cl_context b3OpenCLUtils_createContextFromPlatform(@ByVal cl_platform_id platform, @Cast("cl_device_type") long deviceType, int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + public static native @Cast("cl_context") Pointer b3OpenCLUtils_createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntPointer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + public static native @Cast("cl_context") Pointer b3OpenCLUtils_createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") IntBuffer pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); + public static native @Cast("cl_context") Pointer b3OpenCLUtils_createContextFromPlatform(@Cast("cl_platform_id") Pointer platform, @Cast("cl_device_type") long deviceType, @Cast("cl_int*") int[] pErrNum, Pointer pGLCtx, Pointer pGLDC, int preferredDeviceIndex, int preferredPlatformIndex); // #ifdef __cplusplus diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java index 2c662ec1b7e..a92abc3e7f8 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java @@ -36,7 +36,7 @@ * @author Andrey Krainyak */ @Properties( - inherit = {Bullet3Dynamics.class, clew.class}, + inherit = Bullet3Dynamics.class, value = { @Platform( define = { @@ -104,6 +104,29 @@ private static void mapOCLArrays(InfoMap infoMap, String... typeNames) { public void map(InfoMap infoMap) { infoMap + .put(new Info( + "cl_int", + "cl_uint", + "cl_bool", + "cl_device_local_mem_type" + ).cast().valueTypes("int").pointerTypes("IntPointer", "IntBuffer", "int[]")) + + .put(new Info( + "cl_ulong", + "cl_device_type", + "cl_command_queue_properties" + ).cast().valueTypes("long").pointerTypes("LongPointer", "LongBuffer", "long[]")) + + .put(new Info( + "cl_platform_id", + "cl_device_id", + "cl_context", + "cl_command_queue", + "cl_mem", + "cl_program", + "cl_kernel" + ).cast().valueTypes("Pointer").pointerTypes("PointerPointer")) + .put(new Info( "DEBUG_CHECK_DEQUANTIZATION", "b3Int64", diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/clew.java b/bullet/src/main/java/org/bytedeco/bullet/presets/clew.java deleted file mode 100644 index 7300ae27ac3..00000000000 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/clew.java +++ /dev/null @@ -1,172 +0,0 @@ -/* - * Copyright (C) 2022 Andrey Krainyak - * - * Licensed either under the Apache License, Version 2.0, or (at your option) - * under the terms of the GNU General Public License as published by - * the Free Software Foundation (subject to the "Classpath" exception), - * either version 2, or any later version (collectively, the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * http://www.gnu.org/licenses/ - * http://www.gnu.org/software/classpath/license.html - * - * or as provided in the LICENSE.txt file that accompanied this code. - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.bytedeco.bullet.presets; - -import org.bytedeco.javacpp.Loader; -import org.bytedeco.javacpp.Pointer; -import org.bytedeco.javacpp.annotation.Platform; -import org.bytedeco.javacpp.annotation.Properties; -import org.bytedeco.javacpp.presets.javacpp; -import org.bytedeco.javacpp.tools.Info; -import org.bytedeco.javacpp.tools.InfoMap; -import org.bytedeco.javacpp.tools.InfoMapper; - -/** - * - * @author Andrey Krainyak - */ -@Properties( - inherit = javacpp.class, - value = { - @Platform( - include = { - "clew/clew.h", - "clew_stubs.h", - }, - link = "Bullet3OpenCL_clew@.3.20" - ) - }, - target = "org.bytedeco.bullet.clew" -) -public class clew implements InfoMapper { - static { Loader.checkVersion("org.bytedeco", "bullet"); } - - public void map(InfoMap infoMap) { - infoMap - .put(new Info("cl_bool").cppTypes("bool")) - .put(new Info("cl_int").cppTypes("int")) - .put(new Info("cl_long").cppTypes("long")) - .put(new Info("cl_uint").cppTypes("unsigned int")) - .put(new Info("cl_ulong").cppTypes("unsigned long")) - - .put(new Info( - "CL_HUGE_VAL", - "CL_PROGRAM_STRING_DEBUG_INFO" - ).cppTypes().translate(false)) - - .put(new Info( - "(defined(_WIN32) && defined(_MSC_VER))", - "__APPLE1__", - "defined(CL_NAMED_STRUCT_SUPPORTED) && defined(_MSC_VER)", - "defined(CL_NAMED_STRUCT_SUPPORTED)", - "defined(_WIN32)", - "defined(__AVX__)", - "defined(__GNUC__)", - "defined(__MMX__)", - "defined(__SSE2__)", - "defined(__SSE__)", - "defined(__VEC__)", - "defined(__cl_uchar2__)" - ).define(false)) - - .put(new Info("cl_command_queue").pointerTypes("cl_command_queue")) - .put(new Info("cl_context").pointerTypes("cl_context")) - .put(new Info("cl_device_id").pointerTypes("cl_device_id")) - .put(new Info("cl_event").pointerTypes("cl_event")) - .put(new Info("cl_kernel").pointerTypes("cl_kernel")) - .put(new Info("cl_mem").pointerTypes("cl_mem")) - .put(new Info("cl_platform_id").pointerTypes("cl_platform_id")) - .put(new Info("cl_program").pointerTypes("cl_program")) - .put(new Info("cl_sampler").pointerTypes("cl_sampler")) - - .put(new Info("clew.h").linePatterns( - ".*typedef.*CL_API_ENTRY.*", - "#define clGetExtensionFunctionAddress.*" - ).skip()) - - .put(new Info( - "CL_NAN", - "cl_long2", - "cl_long4", - "cl_long8", - "cl_long16", - "nanf" - ).skip()) - ; - - String[] types = new String[] { - "CHAR", - "UCHAR", - "SHORT", - "USHORT", - "INT", - "UINT", - "LONG", - "ULONG", - "FLOAT", - "DOUBLE", - }; - - for (String type: types) { - for (String size: new String[] { "2", "4", "8", "16" }) { - infoMap.put(new Info( - "defined(__CL_" + type + size + "__)").define(false)); - } - } - } - - public static class cl_command_queue extends Pointer { - public cl_command_queue() { super((Pointer)null); } - public cl_command_queue(Pointer p) { super(p); } - } - - public static class cl_context extends Pointer { - public cl_context() { super((Pointer)null); } - public cl_context(Pointer p) { super(p); } - } - - public static class cl_device_id extends Pointer { - public cl_device_id() { super((Pointer)null); } - public cl_device_id(Pointer p) { super(p); } - } - - public static class cl_event extends Pointer { - public cl_event() { super((Pointer)null); } - public cl_event(Pointer p) { super(p); } - } - - public static class cl_kernel extends Pointer { - public cl_kernel() { super((Pointer)null); } - public cl_kernel(Pointer p) { super(p); } - } - - public static class cl_mem extends Pointer { - public cl_mem() { super((Pointer)null); } - public cl_mem(Pointer p) { super(p); } - } - - public static class cl_platform_id extends Pointer { - public cl_platform_id() { super((Pointer)null); } - public cl_platform_id(Pointer p) { super(p); } - } - - public static class cl_program extends Pointer { - public cl_program() { super((Pointer)null); } - public cl_program(Pointer p) { super(p); } - } - - public static class cl_sampler extends Pointer { - public cl_sampler() { super((Pointer)null); } - public cl_sampler(Pointer p) { super(p); } - } -} diff --git a/bullet/src/main/resources/org/bytedeco/bullet/include/clew_stubs.h b/bullet/src/main/resources/org/bytedeco/bullet/include/clew_stubs.h deleted file mode 100644 index 64b57efb54f..00000000000 --- a/bullet/src/main/resources/org/bytedeco/bullet/include/clew_stubs.h +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright (C) 2022 Andrey Krainyak - * - * Licensed either under the Apache License, Version 2.0, or (at your option) - * under the terms of the GNU General Public License as published by - * the Free Software Foundation (subject to the "Classpath" exception), - * either version 2, or any later version (collectively, the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * http://www.gnu.org/licenses/ - * http://www.gnu.org/software/classpath/license.html - * - * or as provided in the LICENSE.txt file that accompanied this code. - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - - - -// This #ifdef disables these stubs during native code compilation, -// as the stubs should be used for generation of the Java-side -// code only, and the native code should use the original definitions -// provided by clew's header. -#ifdef XXXXXXXXXX - -using BuildProgramCallback = void (*)(cl_program, void*); -cl_int clBuildProgram(cl_program /* program */, cl_uint /* num_devices */, const cl_device_id * /* device_list */, const char * /* options */, BuildProgramCallback, void * /* user_data */); - -using CreateContextCallback = void (*)(const char*, const void*, size_t, void*); -cl_context clCreateContext(const cl_context_properties * /* properties */, cl_uint /* num_devices */, const cl_device_id * /* devices */, CreateContextCallback, void * /* user_data */, cl_int * /* errcode_ret */); -cl_context clCreateContextFromType(const cl_context_properties * /* properties */, cl_device_type /* device_type */, CreateContextCallback, void * /* user_data */, cl_int * /* errcode_ret */); - -using EnqueueNativeKernelCallback = void (*)(void*); -cl_int clEnqueueNativeKernel(cl_command_queue /* command_queue */, EnqueueNativeKernelCallback, void * /* args */, size_t /* cb_args */, cl_uint /* num_mem_objects */, const cl_mem * /* mem_list */, const void ** /* args_mem_loc */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); - -using EventCallback = void (*)(cl_event, cl_int, void*); -cl_int clSetEventCallback(cl_event /* event */, cl_int /* command_exec_callback_type */, EventCallback, void * /* user_data */); - -using MemObjectDestructorCallback = void (*)(cl_mem, void*); -cl_int clSetMemObjectDestructorCallback(cl_mem /* memobj */, MemObjectDestructorCallback, void * /*user_data */); - -/*************************************************************************** - Generated with bullet/gen-clew-stubs script -***************************************************************************/ - -cl_mem clCreateBuffer(cl_context /* context */, cl_mem_flags /* flags */, size_t /* size */, void * /* host_ptr */, cl_int * /* errcode_ret */); -cl_command_queue clCreateCommandQueue(cl_context /* context */, cl_device_id /* device */, cl_command_queue_properties /* properties */, cl_int * /* errcode_ret */); -cl_mem clCreateImage2D(cl_context /* context */, cl_mem_flags /* flags */, const cl_image_format * /* image_format */, size_t /* image_width */, size_t /* image_height */, size_t /* image_row_pitch */, void * /* host_ptr */, cl_int * /* errcode_ret */); -cl_mem clCreateImage3D(cl_context /* context */, cl_mem_flags /* flags */, const cl_image_format * /* image_format */, size_t /* image_width */, size_t /* image_height */, size_t /* image_depth */, size_t /* image_row_pitch */, size_t /* image_slice_pitch */, void * /* host_ptr */, cl_int * /* errcode_ret */); -cl_kernel clCreateKernel(cl_program /* program */, const char * /* kernel_name */, cl_int * /* errcode_ret */); -cl_int clCreateKernelsInProgram(cl_program /* program */, cl_uint /* num_kernels */, cl_kernel * /* kernels */, cl_uint * /* num_kernels_ret */); -cl_program clCreateProgramWithBinary(cl_context /* context */, cl_uint /* num_devices */, const cl_device_id * /* device_list */, const size_t * /* lengths */, const unsigned char ** /* binaries */, cl_int * /* binary_status */, cl_int * /* errcode_ret */); -cl_program clCreateProgramWithSource(cl_context /* context */, cl_uint /* count */, const char ** /* strings */, const size_t * /* lengths */, cl_int * /* errcode_ret */); -cl_sampler clCreateSampler(cl_context /* context */, cl_bool /* normalized_coords */, cl_addressing_mode /* addressing_mode */, cl_filter_mode /* filter_mode */, cl_int * /* errcode_ret */); -cl_mem clCreateSubBuffer(cl_mem /* buffer */, cl_mem_flags /* flags */, cl_buffer_create_type /* buffer_create_type */, const void * /* buffer_create_info */, cl_int * /* errcode_ret */); -cl_event clCreateUserEvent(cl_context /* context */, cl_int * /* errcode_ret */); -cl_int clEnqueueBarrier(cl_command_queue /* command_queue */); -cl_int clEnqueueCopyBuffer(cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_buffer */, size_t /* src_offset */, size_t /* dst_offset */, size_t /* cb */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueCopyBufferRect(cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_buffer */, const size_t * /* src_origin */, const size_t * /* dst_origin */, const size_t * /* region */, size_t /* src_row_pitch */, size_t /* src_slice_pitch */, size_t /* dst_row_pitch */, size_t /* dst_slice_pitch */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueCopyBufferToImage(cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_image */, size_t /* src_offset */, const size_t * /* dst_origin[3] */, const size_t * /* region[3] */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueCopyImage(cl_command_queue /* command_queue */, cl_mem /* src_image */, cl_mem /* dst_image */, const size_t * /* src_origin[3] */, const size_t * /* dst_origin[3] */, const size_t * /* region[3] */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueCopyImageToBuffer(cl_command_queue /* command_queue */, cl_mem /* src_image */, cl_mem /* dst_buffer */, const size_t * /* src_origin[3] */, const size_t * /* region[3] */, size_t /* dst_offset */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -void clEnqueueMapBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_map */, cl_map_flags /* map_flags */, size_t /* offset */, size_t /* cb */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */, cl_int * /* errcode_ret */); -void clEnqueueMapImage(cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_map */, cl_map_flags /* map_flags */, const size_t * /* origin[3] */, const size_t * /* region[3] */, size_t * /* image_row_pitch */, size_t * /* image_slice_pitch */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */, cl_int * /* errcode_ret */); -cl_int clEnqueueMarker(cl_command_queue /* command_queue */, cl_event * /* event */); -cl_int clEnqueueNDRangeKernel(cl_command_queue /* command_queue */, cl_kernel /* kernel */, cl_uint /* work_dim */, const size_t * /* global_work_offset */, const size_t * /* global_work_size */, const size_t * /* local_work_size */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueReadBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */, size_t /* offset */, size_t /* cb */, void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueReadBufferRect(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */, const size_t * /* buffer_origin */, const size_t * /* host_origin */, const size_t * /* region */, size_t /* buffer_row_pitch */, size_t /* buffer_slice_pitch */, size_t /* host_row_pitch */, size_t /* host_slice_pitch */, void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueReadImage(cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_read */, const size_t * /* origin[3] */, const size_t * /* region[3] */, size_t /* row_pitch */, size_t /* slice_pitch */, void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueTask(cl_command_queue /* command_queue */, cl_kernel /* kernel */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueUnmapMemObject(cl_command_queue /* command_queue */, cl_mem /* memobj */, void * /* mapped_ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueWaitForEvents(cl_command_queue /* command_queue */, cl_uint /* num_events */, const cl_event * /* event_list */); -cl_int clEnqueueWriteBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_write */, size_t /* offset */, size_t /* cb */, const void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueWriteBufferRect(cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_write */, const size_t * /* buffer_origin */, const size_t * /* host_origin */, const size_t * /* region */, size_t /* buffer_row_pitch */, size_t /* buffer_slice_pitch */, size_t /* host_row_pitch */, size_t /* host_slice_pitch */, const void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clEnqueueWriteImage(cl_command_queue /* command_queue */, cl_mem /* image */, cl_bool /* blocking_write */, const size_t * /* origin[3] */, const size_t * /* region[3] */, size_t /* input_row_pitch */, size_t /* input_slice_pitch */, const void * /* ptr */, cl_uint /* num_events_in_wait_list */, const cl_event * /* event_wait_list */, cl_event * /* event */); -cl_int clFinish(cl_command_queue /* command_queue */); -cl_int clFlush(cl_command_queue /* command_queue */); -cl_int clGetCommandQueueInfo(cl_command_queue /* command_queue */, cl_command_queue_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetContextInfo(cl_context /* context */, cl_context_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetDeviceIDs(cl_platform_id /* platform */, cl_device_type /* device_type */, cl_uint /* num_entries */, cl_device_id * /* devices */, cl_uint * /* num_devices */); -cl_int clGetDeviceInfo(cl_device_id /* device */, cl_device_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetEventInfo(cl_event /* event */, cl_event_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetEventProfilingInfo(cl_event /* event */, cl_profiling_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -void clGetExtensionFunctionAddress(const char * /* func_name */); -cl_int clGetImageInfo(cl_mem /* image */, cl_image_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetKernelInfo(cl_kernel /* kernel */, cl_kernel_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetKernelWorkGroupInfo(cl_kernel /* kernel */, cl_device_id /* device */, cl_kernel_work_group_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetMemObjectInfo(cl_mem /* memobj */, cl_mem_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetPlatformIDs(cl_uint /* num_entries */, cl_platform_id * /* platforms */, cl_uint * /* num_platforms */); -cl_int clGetPlatformInfo(cl_platform_id /* platform */, cl_platform_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetProgramBuildInfo(cl_program /* program */, cl_device_id /* device */, cl_program_build_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetProgramInfo(cl_program /* program */, cl_program_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetSamplerInfo(cl_sampler /* sampler */, cl_sampler_info /* param_name */, size_t /* param_value_size */, void * /* param_value */, size_t * /* param_value_size_ret */); -cl_int clGetSupportedImageFormats(cl_context /* context */, cl_mem_flags /* flags */, cl_mem_object_type /* image_type */, cl_uint /* num_entries */, cl_image_format * /* image_formats */, cl_uint * /* num_image_formats */); -cl_int clReleaseCommandQueue(cl_command_queue /* command_queue */); -cl_int clReleaseContext(cl_context /* context */); -cl_int clReleaseEvent(cl_event /* event */); -cl_int clReleaseKernel(cl_kernel /* kernel */); -cl_int clReleaseMemObject(cl_mem /* memobj */); -cl_int clReleaseProgram(cl_program /* program */); -cl_int clReleaseSampler(cl_sampler /* sampler */); -cl_int clRetainCommandQueue(cl_command_queue /* command_queue */); -cl_int clRetainContext(cl_context /* context */); -cl_int clRetainEvent(cl_event /* event */); -cl_int clRetainKernel(cl_kernel /* kernel */); -cl_int clRetainMemObject(cl_mem /* memobj */); -cl_int clRetainProgram(cl_program /* program */); -cl_int clRetainSampler(cl_sampler /* sampler */); -// cl_int clSetCommandQueueProperty(cl_command_queue /* command_queue */, cl_command_queue_properties /* properties */, cl_bool /* enable */, cl_command_queue_properties * /* old_properties */); -cl_int clSetKernelArg(cl_kernel /* kernel */, cl_uint /* arg_index */, size_t /* arg_size */, const void * /* arg_value */); -cl_int clSetUserEventStatus(cl_event /* event */, cl_int /* execution_status */); -cl_int clUnloadCompiler(void); -cl_int clWaitForEvents(cl_uint /* num_events */, const cl_event * /* event_list */); - -#endif // XXXXXXXXXX From ed5fe63614b09e4fd9579c3f2acd8737e2107c72 Mon Sep 17 00:00:00 2001 From: Samuel Audet Date: Mon, 28 Mar 2022 13:36:50 +0900 Subject: [PATCH 81/81] Fix presets and module-info.java --- .gitignore | 3 --- README.md | 2 +- .../org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java | 2 ++ .../gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java | 2 ++ .../Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java | 2 ++ .../bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java | 2 ++ .../gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java | 2 ++ .../bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java | 2 ++ .../bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java | 2 ++ .../bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java | 2 ++ .../bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java | 2 ++ .../bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java | 2 ++ .../bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java | 2 ++ .../Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java | 2 ++ .../bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java | 2 ++ .../Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java | 2 ++ .../bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java | 2 ++ .../bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java | 2 ++ .../bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java | 2 ++ .../bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java | 2 ++ .../bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java | 2 ++ .../bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java | 2 ++ .../gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java | 2 ++ .../bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java | 2 ++ .../gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java | 2 ++ .../java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3StridingMeshInterface.java | 2 ++ .../bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java | 2 ++ .../bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java | 2 ++ .../bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java | 2 ++ .../bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java | 2 ++ .../org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java | 2 ++ .../bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java | 2 ++ .../gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java | 2 ++ .../java/org/bytedeco/bullet/presets/Bullet3Collision.java | 4 +--- .../main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java | 2 +- bullet/src/main/java9/module-info.java | 1 - 109 files changed, 211 insertions(+), 9 deletions(-) diff --git a/.gitignore b/.gitignore index 62b9bce9162..ac17fa0deb2 100644 --- a/.gitignore +++ b/.gitignore @@ -15,6 +15,3 @@ # IntelliJ *.iml .idea - -# Python -__pycache__ diff --git a/README.md b/README.md index 2e5d866bc6c..92dd598e9e2 100644 --- a/README.md +++ b/README.md @@ -225,7 +225,7 @@ Each child module in turn relies by default on the included [`cppbuild.sh` scrip * nGraph 0.26.0 https://github.com/NervanaSystems/ngraph * ONNX Runtime 1.10.x https://github.com/microsoft/onnxruntime * TVM 0.8.x https://github.com/apache/tvm - * Bullet Physics SDK 3.21 https://pybullet.org + * Bullet Physics SDK 3.21 https://pybullet.org * LiquidFun http://google.github.io/liquidfun/ * Qt 5.15.x https://download.qt.io/archive/qt/ * Mono/Skia 2.80.x https://github.com/mono/skia diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java index ea2506320bc..1b5c088c15f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/GpuSatCollision.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java index 6dd6d12d149..b0bc4337589 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3AabbOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java index ae50b7bf885..1eece88a534 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BoundSearchCL.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; //for b3SortData (perhaps move it?) diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java index 8cda64e2a51..b009cc83405 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BufferInfoCL.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java index 1e052b2c0f6..e636b89ea45 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfo.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java index 23a74e7cb51..b12196106a8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java index dbdfe2de330..80181fd8238 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhInfoOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java index b933b2750d1..954cfbc6cba 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfo.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java index 7f05bdfcd96..1554b393959 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java index 8ff0b7a25e3..2bec35d14fa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3BvhSubtreeInfoOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java index d4a9ca5d283..1e7ca08cc7e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CharIndexTripletData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java index cbd59db3274..a48ae6a1bae 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CollidableOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java index e326e492734..8369bcd03cf 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java index dcf5f35a630..ad5f225448e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3CompoundOverlappingPairOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java index df7f91e92f4..0674a78779b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4Array.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java index 83ab086ef55..3f3598acebf 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Contact4OCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java index aa12e14a847..437586a52f4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ContactPoint.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java index 0f86b8f7bb8..7a6db1e0ca3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexPolyhedronDataOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java index a7613b9e97b..3f259525938 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ConvexUtilityArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; //for placement new diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java index 05598b353dc..a9189a1b87f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Dispatcher.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java index 7ca1af8641a..710fe2096ac 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FillCL.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java index e343f6acf49..dc230bd3363 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3FloatOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java index de6030f5c5d..51cfb6644e7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkEpaSolver2.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java index 8ffac19a80e..cc58341f369 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GjkPairDetector.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java index fdc4c85d500..7399c04310f 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuBroadphaseInterface.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java index 3f0536e04aa..cffc8ce5af1 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuChildShapeOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java index 6b2ee80997b..628f5387a56 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java index 873335b0203..e06cb9cd333 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4Array.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java index 9ccf597885a..1824b02aaf6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraint4OCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java index f50a69712fa..43696b15551 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuConstraintInfo2.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java index 6ec46836651..0849bba1bc4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuFaceOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java index 4c39352fd3b..f27172fbe38 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraint.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java index f6ad175ab5a..896e31cb023 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java index 4cd8e845920..239101d74b5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGenericConstraintOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java index 82de98bed6c..ed06b4d3d71 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuGridBroadphase.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java index e75161ecc78..362fc82d1b7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuJacobiContactSolver.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java index fe09300779c..2d1744fe34e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhase.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java index ba02eb17354..576b48a6011 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuNarrowPhaseInternalData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java index 4ce601b73da..476f7964b08 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvh.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java index a604bb0e6e4..ef51abdfdb3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuParallelLinearBvhBroadphase.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java index c61da377e68..3355f44253e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsConstraintSolver.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java index 2a289915a7f..eb8e5169586 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuPgsContactSolver.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java index fbdffe4adb3..54f0fa2e0a6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRaycast.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java index 3e6cd55d163..2acca266a3c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipeline.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java index c34a734728c..6964281ae16 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuRigidBodyPipelineInternalData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java index b248eb6c95c..6b08cebf885 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSapBroadphase.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java index 8c1625335c8..6300139e427 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverBody.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java index 037a99b916d..97108e79a94 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3GpuSolverConstraint.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java index 7c5ba118258..fd5c6147459 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IndexedMesh.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java index f506faa6391..2d901f0fd1e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java index d6c8e452114..d434e6b291a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InertiaDataOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java index 29978a76345..512e95a0edb 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int2OCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java index 0db64a4cdda..5e633fb486a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Int4OCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java index 39db1c42412..0dfab25875a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntIndexData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java index aad6528d3ed..7d008ec77f5 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3IntOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java index 72ac26cb20f..be7132162be 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3InternalTriangleIndexCallback.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java index c6a44eafecd..432e70001bf 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3JacobiSolverInfo.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java index c42a4e15384..dd363c4bc27 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3KernelArgData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java index 6d317422a9b..f770cd9dfb4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3LauncherCL.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java index 79877fe441e..b564b47a38e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3MeshPartData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java index d1d1c60e50e..d375a3843af 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3NodeOverlapCallback.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java index be831e968ca..04145e8c56b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLDeviceInfo.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java index a90a9286424..cfb24e24992 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLPlatformInfo.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java index a01492e82ea..61d4c78bde9 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OpenCLUtils.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java index 1f9d690cbfd..66c23749d3c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvh.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java index 42e28493b36..65da62d6b0b 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java index e5513a844b9..97b7a63c675 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNode.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java index 17535adbb34..5502e0c7041 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeDoubleData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java index a691d9569d8..00e8609f9e6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3OptimizedBvhNodeFloatData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java index a87f7902e5b..fa873c6250c 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ParamsGridBroadphaseCL.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java index 2bba3bd2ffe..c0ff64215db 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3PrefixScanFloat4CL.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java index 7ec03af612c..f6d47ab9173 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvh.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java index 4c4a9bfb7d7..862b8a512e6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhDoubleData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java index 88252fc686a..0584749c655 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhFloatData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java index 7bb1187a251..419b12098fc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNode.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java index 254bca99533..442f1648cf3 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java index d4c252233f4..8d8a48316a0 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3QuantizedBvhNodeOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java index 9d6ef8a373e..43715f121fe 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RadixSort32CL.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java index 2ec98332e6f..efdeb276597 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RayInfoOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java index 7cd35b216a3..47ce766b09d 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3RigidBodyDataOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java index 6ad6332d99e..1363e66068a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabb.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java index 6f734a6de5a..5a53778886e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java index 7707333529f..860505f77c8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SapAabbOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java index 8bc7b76f734..ce5fa3a1230 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Serializer.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java index a2fce1064b3..24b8be5a228 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java index 14dc32dccc7..7a95ee61fef 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3ShortIntIndexTripletData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java index 2aafd76c189..2909de73766 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Solver.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java index e3f9e779305..a9dc175463a 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SolverBase.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java index 48d1181289d..c3903d98113 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java index 46d4a9e6c02..29d0cd828a6 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java index 8b16c9b3afe..a897642fea4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SortDataOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java index 1f576b7fe2c..f325b86efed 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterface.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java index 86970b32584..2747e54ac20 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3StridingMeshInterfaceData.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java index 1ebf3a288fa..b3b3020c703 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3SubSimplexClosestResult.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java index e2163f1d81d..52e1579386e 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleCallback.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java index 4bf92dc2716..5b47b40a9de 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java index d4c2958aa00..e5d1b0d8a09 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3TriangleIndexVertexArrayArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java index 277f6980ebc..44ef1f31caa 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java index 4ab245c1822..93dddf789ee 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedCharOCLArrayArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java index cab253cc459..863b3756cfc 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UnsignedIntOCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java index cee74872fb3..83d0ae47150 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3UsageBitfield.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java index 44531361f3f..4bdd6d664b4 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3Vector3OCLArray.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java index 95f8cdb5356..7103b7b6bd7 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/Bullet3OpenCL/b3VoronoiSimplexSolver.java @@ -13,6 +13,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; import static org.bytedeco.bullet.global.Bullet3OpenCL.*; diff --git a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java index c08c3f5cc38..42d6c3235a8 100644 --- a/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java +++ b/bullet/src/gen/java/org/bytedeco/bullet/global/Bullet3OpenCL.java @@ -15,6 +15,8 @@ import static org.bytedeco.bullet.global.Bullet3Collision.*; import org.bytedeco.bullet.Bullet3Dynamics.*; import static org.bytedeco.bullet.global.Bullet3Dynamics.*; +import org.bytedeco.bullet.LinearMath.*; +import static org.bytedeco.bullet.global.LinearMath.*; public class Bullet3OpenCL extends org.bytedeco.bullet.presets.Bullet3OpenCL { static { Loader.load(); } diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java index ea67bceaef5..27ef56197c9 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3Collision.java @@ -63,10 +63,8 @@ "Bullet3Collision/NarrowPhaseCollision/shared/b3QuantizedBvhNodeData.h", "Bullet3Collision/NarrowPhaseCollision/shared/b3ReduceContacts.h", }, - link = "Bullet3Collision@.3.20", - preload = "Bullet3Geometry@.3.20" + link = {"Bullet3Geometry@.3.20", "Bullet3Collision@.3.20"} ), - @Platform(value = "windows", link = { "Bullet3Collision@.3.20", "Bullet3Geometry@.3.20" }) }, target = "org.bytedeco.bullet.Bullet3Collision", global = "org.bytedeco.bullet.global.Bullet3Collision" diff --git a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java index a92abc3e7f8..59159a61696 100644 --- a/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java +++ b/bullet/src/main/java/org/bytedeco/bullet/presets/Bullet3OpenCL.java @@ -36,7 +36,7 @@ * @author Andrey Krainyak */ @Properties( - inherit = Bullet3Dynamics.class, + inherit = {Bullet3Dynamics.class, LinearMath.class}, value = { @Platform( define = { diff --git a/bullet/src/main/java9/module-info.java b/bullet/src/main/java9/module-info.java index 0a4b0eccbf0..18a42688a5e 100644 --- a/bullet/src/main/java9/module-info.java +++ b/bullet/src/main/java9/module-info.java @@ -1,6 +1,5 @@ module org.bytedeco.bullet { requires transitive org.bytedeco.javacpp; - exports org.bytedeco.bullet; exports org.bytedeco.bullet.global; exports org.bytedeco.bullet.presets; exports org.bytedeco.bullet.LinearMath;